packages feed

skylighting (empty) → 0.1.0.0

raw patch · 200 files changed

+221632/−0 lines, 200 filesdep +Diffdep +HUnitdep +QuickChecksetup-changed

Dependencies added: Diff, HUnit, QuickCheck, aeson, base, blaze-html, bytestring, case-insensitive, containers, directory, filepath, hxt, mtl, pretty-show, regex-pcre-builtin, safe, skylighting, tasty, tasty-golden, tasty-hunit, text, utf8-string

Files

+ LICENSE view
@@ -0,0 +1,339 @@+             GNU GENERAL PUBLIC LICENSE+                Version 2, June 1991++ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA+ Everyone is permitted to copy and distribute verbatim copies+ of this license document, but changing it is not allowed.++                     Preamble++  The licenses for most software are designed to take away your+freedom to share and change it.  By contrast, the GNU General Public+License is intended to guarantee your freedom to share and change free+software--to make sure the software is free for all its users.  This+General Public License applies to most of the Free Software+Foundation's software and to any other program whose authors commit to+using it.  (Some other Free Software Foundation software is covered by+the GNU Lesser General Public License instead.)  You can apply it to+your programs, too.++  When we speak of free software, we are referring to freedom, not+price.  Our General Public Licenses are designed to make sure that you+have the freedom to distribute copies of free software (and charge for+this service if you wish), that you receive source code or can get it+if you want it, that you can change the software or use pieces of it+in new free programs; and that you know you can do these things.++  To protect your rights, we need to make restrictions that forbid+anyone to deny you these rights or to ask you to surrender the rights.+These restrictions translate to certain responsibilities for you if you+distribute copies of the software, or if you modify it.++  For example, if you distribute copies of such a program, whether+gratis or for a fee, you must give the recipients all the rights that+you have.  You must make sure that they, too, receive or can get the+source code.  And you must show them these terms so they know their+rights.++  We protect your rights with two steps: (1) copyright the software, and+(2) offer you this license which gives you legal permission to copy,+distribute and/or modify the software.++  Also, for each author's protection and ours, we want to make certain+that everyone understands that there is no warranty for this free+software.  If the software is modified by someone else and passed on, we+want its recipients to know that what they have is not the original, so+that any problems introduced by others will not reflect on the original+authors' reputations.++  Finally, any free program is threatened constantly by software+patents.  We wish to avoid the danger that redistributors of a free+program will individually obtain patent licenses, in effect making the+program proprietary.  To prevent this, we have made it clear that any+patent must be licensed for everyone's free use or not licensed at all.++  The precise terms and conditions for copying, distribution and+modification follow.++             GNU GENERAL PUBLIC LICENSE+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION++  0. This License applies to any program or other work which contains+a notice placed by the copyright holder saying it may be distributed+under the terms of this General Public License.  The "Program", below,+refers to any such program or work, and a "work based on the Program"+means either the Program or any derivative work under copyright law:+that is to say, a work containing the Program or a portion of it,+either verbatim or with modifications and/or translated into another+language.  (Hereinafter, translation is included without limitation in+the term "modification".)  Each licensee is addressed as "you".++Activities other than copying, distribution and modification are not+covered by this License; they are outside its scope.  The act of+running the Program is not restricted, and the output from the Program+is covered only if its contents constitute a work based on the+Program (independent of having been made by running the Program).+Whether that is true depends on what the Program does.++  1. You may copy and distribute verbatim copies of the Program's+source code as you receive it, in any medium, provided that you+conspicuously and appropriately publish on each copy an appropriate+copyright notice and disclaimer of warranty; keep intact all the+notices that refer to this License and to the absence of any warranty;+and give any other recipients of the Program a copy of this License+along with the Program.++You may charge a fee for the physical act of transferring a copy, and+you may at your option offer warranty protection in exchange for a fee.++  2. You may modify your copy or copies of the Program or any portion+of it, thus forming a work based on the Program, and copy and+distribute such modifications or work under the terms of Section 1+above, provided that you also meet all of these conditions:++    a) You must cause the modified files to carry prominent notices+    stating that you changed the files and the date of any change.++    b) You must cause any work that you distribute or publish, that in+    whole or in part contains or is derived from the Program or any+    part thereof, to be licensed as a whole at no charge to all third+    parties under the terms of this License.++    c) If the modified program normally reads commands interactively+    when run, you must cause it, when started running for such+    interactive use in the most ordinary way, to print or display an+    announcement including an appropriate copyright notice and a+    notice that there is no warranty (or else, saying that you provide+    a warranty) and that users may redistribute the program under+    these conditions, and telling the user how to view a copy of this+    License.  (Exception: if the Program itself is interactive but+    does not normally print such an announcement, your work based on+    the Program is not required to print an announcement.)++These requirements apply to the modified work as a whole.  If+identifiable sections of that work are not derived from the Program,+and can be reasonably considered independent and separate works in+themselves, then this License, and its terms, do not apply to those+sections when you distribute them as separate works.  But when you+distribute the same sections as part of a whole which is a work based+on the Program, the distribution of the whole must be on the terms of+this License, whose permissions for other licensees extend to the+entire whole, and thus to each and every part regardless of who wrote it.++Thus, it is not the intent of this section to claim rights or contest+your rights to work written entirely by you; rather, the intent is to+exercise the right to control the distribution of derivative or+collective works based on the Program.++In addition, mere aggregation of another work not based on the Program+with the Program (or with a work based on the Program) on a volume of+a storage or distribution medium does not bring the other work under+the scope of this License.++  3. You may copy and distribute the Program (or a work based on it,+under Section 2) in object code or executable form under the terms of+Sections 1 and 2 above provided that you also do one of the following:++    a) Accompany it with the complete corresponding machine-readable+    source code, which must be distributed under the terms of Sections+    1 and 2 above on a medium customarily used for software interchange; or,++    b) Accompany it with a written offer, valid for at least three+    years, to give any third party, for a charge no more than your+    cost of physically performing source distribution, a complete+    machine-readable copy of the corresponding source code, to be+    distributed under the terms of Sections 1 and 2 above on a medium+    customarily used for software interchange; or,++    c) Accompany it with the information you received as to the offer+    to distribute corresponding source code.  (This alternative is+    allowed only for noncommercial distribution and only if you+    received the program in object code or executable form with such+    an offer, in accord with Subsection b above.)++The source code for a work means the preferred form of the work for+making modifications to it.  For an executable work, complete source+code means all the source code for all modules it contains, plus any+associated interface definition files, plus the scripts used to+control compilation and installation of the executable.  However, as a+special exception, the source code distributed need not include+anything that is normally distributed (in either source or binary+form) with the major components (compiler, kernel, and so on) of the+operating system on which the executable runs, unless that component+itself accompanies the executable.++If distribution of executable or object code is made by offering+access to copy from a designated place, then offering equivalent+access to copy the source code from the same place counts as+distribution of the source code, even though third parties are not+compelled to copy the source along with the object code.++  4. You may not copy, modify, sublicense, or distribute the Program+except as expressly provided under this License.  Any attempt+otherwise to copy, modify, sublicense or distribute the Program is+void, and will automatically terminate your rights under this License.+However, parties who have received copies, or rights, from you under+this License will not have their licenses terminated so long as such+parties remain in full compliance.++  5. You are not required to accept this License, since you have not+signed it.  However, nothing else grants you permission to modify or+distribute the Program or its derivative works.  These actions are+prohibited by law if you do not accept this License.  Therefore, by+modifying or distributing the Program (or any work based on the+Program), you indicate your acceptance of this License to do so, and+all its terms and conditions for copying, distributing or modifying+the Program or works based on it.++  6. Each time you redistribute the Program (or any work based on the+Program), the recipient automatically receives a license from the+original licensor to copy, distribute or modify the Program subject to+these terms and conditions.  You may not impose any further+restrictions on the recipients' exercise of the rights granted herein.+You are not responsible for enforcing compliance by third parties to+this License.++  7. If, as a consequence of a court judgment or allegation of patent+infringement or for any other reason (not limited to patent issues),+conditions are imposed on you (whether by court order, agreement or+otherwise) that contradict the conditions of this License, they do not+excuse you from the conditions of this License.  If you cannot+distribute so as to satisfy simultaneously your obligations under this+License and any other pertinent obligations, then as a consequence you+may not distribute the Program at all.  For example, if a patent+license would not permit royalty-free redistribution of the Program by+all those who receive copies directly or indirectly through you, then+the only way you could satisfy both it and this License would be to+refrain entirely from distribution of the Program.++If any portion of this section is held invalid or unenforceable under+any particular circumstance, the balance of the section is intended to+apply and the section as a whole is intended to apply in other+circumstances.++It is not the purpose of this section to induce you to infringe any+patents or other property right claims or to contest validity of any+such claims; this section has the sole purpose of protecting the+integrity of the free software distribution system, which is+implemented by public license practices.  Many people have made+generous contributions to the wide range of software distributed+through that system in reliance on consistent application of that+system; it is up to the author/donor to decide if he or she is willing+to distribute software through any other system and a licensee cannot+impose that choice.++This section is intended to make thoroughly clear what is believed to+be a consequence of the rest of this License.++  8. If the distribution and/or use of the Program is restricted in+certain countries either by patents or by copyrighted interfaces, the+original copyright holder who places the Program under this License+may add an explicit geographical distribution limitation excluding+those countries, so that distribution is permitted only in or among+countries not thus excluded.  In such case, this License incorporates+the limitation as if written in the body of this License.++  9. The Free Software Foundation may publish revised and/or new versions+of the General Public License from time to time.  Such new versions will+be similar in spirit to the present version, but may differ in detail to+address new problems or concerns.++Each version is given a distinguishing version number.  If the Program+specifies a version number of this License which applies to it and "any+later version", you have the option of following the terms and conditions+either of that version or of any later version published by the Free+Software Foundation.  If the Program does not specify a version number of+this License, you may choose any version ever published by the Free Software+Foundation.++  10. If you wish to incorporate parts of the Program into other free+programs whose distribution conditions are different, write to the author+to ask for permission.  For software which is copyrighted by the Free+Software Foundation, write to the Free Software Foundation; we sometimes+make exceptions for this.  Our decision will be guided by the two goals+of preserving the free status of all derivatives of our free software and+of promoting the sharing and reuse of software generally.++                     NO WARRANTY++  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,+REPAIR OR CORRECTION.++  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE+POSSIBILITY OF SUCH DAMAGES.++              END OF TERMS AND CONDITIONS++     How to Apply These Terms to Your New Programs++  If you develop a new program, and you want it to be of the greatest+possible use to the public, the best way to achieve this is to make it+free software which everyone can redistribute and change under these terms.++  To do so, attach the following notices to the program.  It is safest+to attach them to the start of each source file to most effectively+convey the exclusion of warranty; and each file should have at least+the "copyright" line and a pointer to where the full notice is found.++    <one line to give the program's name and a brief idea of what it does.>+    Copyright (C) <year>  <name of author>++    This program is free software; you can redistribute it and/or modify+    it under the terms of the GNU General Public License as published by+    the Free Software Foundation; either version 2 of the License, or+    (at your option) any later version.++    This program is distributed in the hope that it will be useful,+    but WITHOUT ANY WARRANTY; without even the implied warranty of+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the+    GNU General Public License for more details.++    You should have received a copy of the GNU General Public License along+    with this program; if not, write to the Free Software Foundation, Inc.,+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.++Also add information on how to contact you by electronic and paper mail.++If the program is interactive, make it output a short notice like this+when it starts in an interactive mode:++    Gnomovision version 69, Copyright (C) year name of author+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.+    This is free software, and you are welcome to redistribute it+    under certain conditions; type `show c' for details.++The hypothetical commands `show w' and `show c' should show the appropriate+parts of the General Public License.  Of course, the commands you use may+be called something other than `show w' and `show c'; they could even be+mouse-clicks or menu items--whatever suits your program.++You should also get your employer (if you work as a programmer) or your+school, if any, to sign a "copyright disclaimer" for the program, if+necessary.  Here is a sample; alter the names:++  Yoyodyne, Inc., hereby disclaims all copyright interest in the program+  `Gnomovision' (which makes passes at compilers) written by James Hacker.++  <signature of Ty Coon>, 1 April 1989+  Ty Coon, President of Vice++This General Public License does not permit incorporating your program into+proprietary programs.  If your program is a subroutine library, you may+consider it more useful to permit linking proprietary applications with the+library.  If this is what you want to do, use the GNU Lesser General+Public License instead of this License.
+ README.md view
@@ -0,0 +1,100 @@+skylighting+===========++[![license](https://img.shields.io/badge/license-GPLv2+-brightgreen.svg)](https://www.gnu.org/licenses/gpl.html)+[![travis build status](https://img.shields.io/travis/jgm/skylighting.svg)](https://travis-ci.org/jgm/skylighting)++A Haskell syntax highlighting library with tokenizers derived+from KDE XML syntax highlighting descriptions.++A command-line highlighter, `skylighting`, is also provided.++Motivation+----------++This library is the successor to [highlighting-kate], which had+some problems that were difficult to resolve given its+architecture.++In highlighting-kate, the XML syntax descriptions were converted+into individual parsec parsers, which were then compiled.  This+made it difficult to handle IncludeRules properly without+circular imports.  There was also no way to load a syntax+description dynamically.++Skylighting, by contrast, parses the XML syntax descriptions+into Haskell data structures, which are then interpreted by+a "tokenize" function.  IncludeRules can now be handled+properly, and users can add new syntax descriptions+dynamically.  It is also now possible to convert `.theme` files+directly into styles.++Installing+----------++To install the latest release from Hackage, do++    stack install skylighting+or++    cabal install skylighting++If you want the command-line tool, set the `executable` flag+using `--flag "skylighting:executable"` in stack or+`-fexecutable` in cabal.++The release tarballs include generated files not present in this+repository.  Building from this repository is a two-step+process.  In the first step we build a program,+`skylighting-extract`, which reads XML syntax highlighting+definitions from the `xml` directory and writes Haskell source+files.  In the second we actually build the library.++Using stack:++    make bootstrap+    make++Using cabal:++    cabal install -fbootstrap --disable-optimizations+    cabal run skylighting-extract -- xml/*.xml+    cabal install -f-bootstrap --disable-optimizations++Command-line tool+-----------------++A command-line executable, `skylighting`, is installed if+the `executable` cabal flag is set in building.++For help, `skylighting --help`.++Adding new syntaxes+-------------------++To compile with additional syntaxes, simply add the syntax+definition (XML) file to the `xml` directory and repeat the+bootstrap build described above.++Note that both the library and the executable can dynamically+load syntax definitions, so you may not need to compile them+in.++License+-------++Skylighting is licensed under the GPL, because some of the xml+syntax descriptions from which its tokenizers are generated are+GPL-licensed.++References+----------++Kate syntax highlighting documentation:+<https://docs.kde.org/stable5/en/applications/katepart/highlight.html>++Kate highlighting definitions:+<https://github.com/KDE/syntax-highlighting/tree/master/data/syntax>++[highlighting-kate]: https://github.com/jgm/highlighting-kate+
+ Setup.hs view
@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMain
+ bin/extract.hs view
@@ -0,0 +1,90 @@+{-# LANGUAGE Arrows #-}++import Data.Either (partitionEithers)+import Data.List (intercalate, isInfixOf)+import qualified Data.Text as Text+import Skylighting.Parser (missingIncludes, parseSyntaxDefinition)+import Skylighting.Types+import System.Directory+import System.Environment (getArgs)+import System.Exit+import System.IO (hPutStrLn, stderr)+import Text.Show.Pretty (ppShow)+import qualified Data.Map as Map++main :: IO ()+main = do+  createDirectoryIfMissing True "src/Skylighting/Syntax"+  files <- getArgs+  (errs, syntaxes) <- partitionEithers <$> mapM parseSyntaxDefinition files+  mapM_ (hPutStrLn stderr) errs+  mapM_ writeModuleFor syntaxes++  case missingIncludes syntaxes of+       [] -> return ()+       ns -> do+         mapM_ (\(syn,dep) -> hPutStrLn stderr+             ("Missing syntax definition: " ++ Text.unpack syn ++ " requires " +++               Text.unpack dep ++ " through IncludeRules.")) ns+         hPutStrLn stderr "Fatal error."+         exitWith (ExitFailure 1)++  putStrLn "Backing up skylighting.cabal to skylighting.cabal.orig"+  copyFile "skylighting.cabal" "skylighting.cabal.orig"++  putStrLn "Updating module list in skylighting.cabal"+  cabalLines <- lines <$> readFile "skylighting.cabal.orig"+  let (top, rest) = break ("other-modules:" `isInfixOf`) cabalLines+  let (_, bottom) = span ("Skylighting.Syntax." `isInfixOf`) (drop 1 rest)+  let modulenames = map (\s -> "Skylighting.Syntax." +++                          Text.unpack (sShortname s)) syntaxes+  let autogens = map ((replicate 23 ' ') ++) modulenames+  let newcabal = unlines $ top ++ ("  other-modules:" : autogens) ++ bottom+  writeFile "skylighting.cabal" newcabal++  putStrLn "Writing src/Skylighting/Syntax.hs"+  writeFile "src/Skylighting/Syntax.hs" $ unlines (+     [ "{-# LANGUAGE OverloadedStrings #-}"+     , "module Skylighting.Syntax (defaultSyntaxMap) where"+     , "import qualified Data.Map as Map"+     , "import Skylighting.Types" ] +++     [ "import qualified " ++ m | m <- modulenames ]+     +++     [ ""+     , "defaultSyntaxMap :: SyntaxMap"+     , "defaultSyntaxMap = Map.fromList ["+     ]) ++ "   " +++     (intercalate "\n  ,"+       ["  (" ++ show (Text.unpack $ sName s) ++ ", "+              ++ "Skylighting.Syntax." ++ Text.unpack (sShortname s) ++ ".syntax)"+                  | s <- syntaxes ]) ++ " ]"++writeModuleFor :: Syntax -> IO ()+writeModuleFor syn = do+  let fp = toPathName syn+  putStrLn $ "Writing " ++ fp+  let isregex (RegExpr{}) = True+      isregex _           = False+  let iskeyword (Keyword{}) = True+      iskeyword _           = False+  let matchers = map rMatcher $ concatMap cRules $ Map.elems $ sContexts syn+  let usesRegex = any isregex matchers+  let usesSet = any iskeyword matchers+  writeFile fp $ unlines $+    [ "{-# LANGUAGE OverloadedStrings #-}"+    , "module Skylighting.Syntax." ++ Text.unpack (sShortname syn) +++        " (syntax) where"+    , ""+    , "import Skylighting.Types"+    , "import Data.Map" ] +++    [ "import Skylighting.Regex" | usesRegex ] +++    [ "import qualified Data.Set" | usesSet ] +++    [ ""+    , "syntax :: Syntax"+    , "syntax = " ++ ppShow syn ]++toPathName :: Syntax -> String+toPathName s =+  "src/Skylighting/Syntax/" +++  map (\c -> if c == '.' then '/' else c)+      (Text.unpack (sShortname s)) ++ ".hs"
+ bin/main.hs view
@@ -0,0 +1,243 @@+{-# LANGUAGE OverloadedStrings #-}++import Control.Monad+import qualified Data.ByteString.Lazy as BL+import Data.Char (toLower)+import qualified Data.Map as Map+import Data.Monoid+import qualified Data.Text as Text+import qualified Data.Text.IO as Text+import Data.Version (showVersion)+import Paths_skylighting (version)+import Skylighting+import System.Console.GetOpt+import System.Environment+import System.Exit+import System.IO (hPutStrLn, stderr)+import Text.Blaze.Html.Renderer.String+import qualified Text.Blaze.Html5 as H+import qualified Text.Blaze.Html5.Attributes as A+import Text.Printf (printf)+import Text.Show.Pretty (ppShow)++data Flag = Sty String+          | Theme String+          | Format String+          | Help+          | Fragment+          | List+          | NumberLines+          | Syn String+          | TitleAttributes+          | Definition String+          | Trace+          | Version+          deriving (Eq, Show)++data HighlightFormat = FormatHtml+                     | FormatLaTeX+                     | FormatNative+                     deriving (Eq, Show)++options :: [OptDescr Flag]+options =+  [Option ['S']+          ["style"]+          (ReqArg Sty "STYLE")+          "specify style"+  ,Option ['t']+          ["theme"]+          (ReqArg Theme "PATH")+          "KDE theme file to be used as style"+  ,Option ['f']+          ["format"]+          (ReqArg Format "FORMAT")+          "output format (html|latex|native)"+  ,Option ['r']+          ["fragment"]+          (NoArg Fragment)+          "fragment, without document header"+  ,Option ['h']+          ["help"]+          (NoArg Help)+          "show usage message"+  ,Option ['l']+          ["list"]+          (NoArg List)+          "list available language syntaxes"+  ,Option ['n']+          ["number-lines"]+          (NoArg NumberLines)+          "number lines"+  ,Option ['s']+          ["syntax"]+          (ReqArg Syn "SYNTAX")+          "specify language syntax to use"+  ,Option ['a']+          ["title-attributes"]+          (NoArg TitleAttributes)+          "include structure in title attributes"+  ,Option ['d']+          ["definition"]+          (ReqArg Definition "PATH")+          "load xml syntax definition file (may be repeated)"+  ,Option ['T']+          ["trace"]+          (NoArg Trace)+          "trace tokenizer for debugging"+  ,Option ['v']+          ["version"]+          (NoArg Version)+          "print version"]++syntaxOf :: SyntaxMap -> [FilePath] -> [Flag] -> IO Syntax+syntaxOf smap fps [] = case concatMap (syntaxesByFilename smap) fps of+                             (s:_) -> return s+                             _     -> err "No syntax specified: use --syntax."+syntaxOf smap _ (Syn lang : _) = do+  case lookupSyntax (Text.pack lang) smap of+         Just s  -> return s+         Nothing -> err ("Could not find syntax definition for " ++ lang)+syntaxOf smap fps (_:xs) = syntaxOf smap fps xs++styleOf :: [Flag] -> IO Style+styleOf [] = return kate+styleOf (Theme fp : _) = do+  raw <- BL.readFile fp+  case parseTheme raw of+       Left e    -> err e+       Right sty -> return sty+styleOf (Sty s : _) = case map toLower s of+                            "pygments"   -> return pygments+                            "espresso"   -> return espresso+                            "kate"       -> return kate+                            "tango"      -> return tango+                            "haddock"    -> return haddock+                            "monochrome" -> return monochrome+                            _            -> err $ "Unknown style: " ++ s+styleOf (_ : xs) = styleOf xs++formatOf :: [Flag] -> IO HighlightFormat+formatOf [] = return FormatHtml  -- default+formatOf (Format s : _) = case map toLower s of+                            "html"   -> return FormatHtml+                            "latex"  -> return FormatLaTeX+                            "native" -> return FormatNative+                            _        -> err $ "Unknown format: " ++ s+formatOf (_ : xs) = formatOf xs++extractDefinitions :: [Flag] -> IO [Syntax]+extractDefinitions [] = return []+extractDefinitions (Definition fp : xs) = do+  res <- parseSyntaxDefinition fp+  case res of+       Left e -> err e+       Right s -> do+         putStrLn $ "Loaded syntax definition for " ++ Text.unpack (sName s)+         (s:) <$> extractDefinitions xs+extractDefinitions (_:xs) = extractDefinitions xs++err :: String -> IO a+err msg = do+  hPutStrLn stderr msg+  exitWith (ExitFailure 1)++main :: IO ()+main = do+  (opts, fnames, errs) <- getArgs >>= return . getOpt Permute options+  prg <- getProgName+  let usageHeader = prg ++ " [options] [files...]"++  when (not (null errs)) $+     err (concat errs ++ usageInfo usageHeader options)++  when (Help `elem` opts) $ do+     hPutStrLn stderr (usageInfo usageHeader options)+     exitWith ExitSuccess++  when (Version `elem` opts) $ do+     putStrLn (prg ++ " " ++ showVersion version)+     exitWith ExitSuccess++  syntaxMap' <- foldr addSyntaxDefinition defaultSyntaxMap <$>+                    extractDefinitions opts++  case missingIncludes (Map.elems syntaxMap') of+       [] -> return ()+       xs -> err $ "Missing syntax definitions:\n" +++              unlines (map+                  (\(syn,dep) -> (Text.unpack syn ++ " requires " +++                    Text.unpack dep ++ " through IncludeRules.")) xs)++  when (List `elem` opts) $ do+     let printSyntaxNames s = putStrLn (printf "%s (%s)"+                                       (Text.unpack (Text.toLower (sShortname s)))+                                       (Text.unpack (sName s)))+     mapM_ printSyntaxNames $ Map.elems syntaxMap'+     exitWith ExitSuccess++  code <- if null fnames+             then Text.getContents+             else mconcat <$> mapM Text.readFile fnames++  let highlightOpts = defaultFormatOpts{ titleAttributes = TitleAttributes `elem` opts+                                       , numberLines = NumberLines `elem` opts+                                       , lineAnchors = NumberLines `elem` opts+                                       }+  let fragment = Fragment `elem` opts+  let fname = case fnames of+                    []    -> ""+                    (x:_) -> x+  let trace = Trace `elem` opts++  syntax <- syntaxOf syntaxMap' fnames opts+  style <- styleOf opts+  format <- formatOf opts++  let config = TokenizerConfig { traceOutput = trace+                               , syntaxMap = syntaxMap' }++  sourceLines <- case tokenize config syntax code of+                      Left e   -> err e+                      Right ls -> return ls++  case format of+       FormatHtml   -> hlHtml fragment fname highlightOpts style sourceLines+       FormatLaTeX  -> hlLaTeX fragment fname highlightOpts style sourceLines+       FormatNative -> putStrLn $ ppShow sourceLines++hlHtml :: Bool               -- ^ Fragment+      -> FilePath            -- ^ Filename+      -> FormatOptions+      -> Style+      -> [SourceLine]+      -> IO ()+hlHtml frag fname opts sty sourceLines =+ if frag+    then putStrLn $ renderHtml fragment+    else putStrLn $ renderHtml $ H.html $+           H.head (pageTitle >> metadata >> css) >> H.body (H.toHtml fragment)+  where fragment = formatHtmlBlock opts sourceLines+        css = H.style H.! A.type_ "text/css" $ H.toHtml $ styleToCss sty+        pageTitle = H.title $ H.toHtml fname+        metadata = do+          H.meta H.! A.charset "utf-8"+          H.meta H.! A.name "generator" H.! A.content "highlight-kate"++hlLaTeX :: Bool               -- ^ Fragment+        -> FilePath            -- ^ Filename+        -> FormatOptions+        -> Style+        -> [SourceLine]+        -> IO ()+hlLaTeX frag fname opts sty sourceLines =+ if frag+    then Text.putStrLn fragment+    else Text.putStrLn $+            "\\documentclass{article}\n\\usepackage[margin=1in]{geometry}\n" <>+             macros <> pageTitle <>+             "\n\\begin{document}\n\\maketitle\n" <> fragment <> "\n\\end{document}"+  where fragment = formatLaTeXBlock opts sourceLines+        macros = styleToLaTeX sty+        pageTitle = "\\title{" <> Text.pack fname <> "}\n"+
+ changelog.md view
@@ -0,0 +1,6 @@+# Revision history for skylighting++## 0.1.0.0  -- 2016-12-23++* Initial release+
+ prelude/Prelude.hs view
@@ -0,0 +1,26 @@+{-# LANGUAGE PackageImports #-}+{-# LANGUAGE CPP #-}++-- This custom Prelude emulates the API of the prelude+-- with base 4.8.++module Prelude+(+  module P+#if MIN_VERSION_base(4,8,0)+#else+, Monoid(..)+, Applicative(..)+, (<$>)+, (<$)+#endif+)+where++#if MIN_VERSION_base(4,8,0)+import "base" Prelude as P+#else+import "base" Prelude as P+import Control.Applicative+import Data.Monoid+#endif
+ skylighting.cabal view
@@ -0,0 +1,336 @@+name:                skylighting+version:             0.1.0.0+synopsis:            syntax highlighting library+description:         Skylighting is a syntax highlighting library with+                     support for over one hundred languages.  It derives+                     its tokenizers from XML syntax definitions used+                     by KDE's KSyntaxHighlighting framework, so any+                     syntax supported by that framework can be added.+                     An optional command-line program is provided.++                     Skylighting is intended to be the successor to+                     highlighting-kate.++homepage:            https://github.com/jgm/skylighting+license:             GPL-2+license-file:        LICENSE+author:              John MacFarlane+maintainer:          jgm@berkeley.edu+copyright:           (C) 2016 John MacFarlane+category:            Text+build-type:          Simple+extra-source-files:  changelog.md+                     README.md+                     test/default.theme+                     test/cases/abc.ada+                     test/cases/abc.agda+                     test/cases/abc.c+                     test/cases/abc.clojure+                     test/cases/abc.cpp+                     test/cases/abc.cs+                     test/cases/abc.d+                     test/cases/abc.fortran+                     test/cases/abc.go+                     test/cases/abc.haskell+                     test/cases/abc.java+                     test/cases/abc.javascript+                     test/cases/abc.julia+                     test/cases/abc.kotlin+                     test/cases/abc.lisp+                     test/cases/abc.matlab+                     test/cases/abc.ocaml+                     test/cases/abc.perl+                     test/cases/abc.php+                     test/cases/abc.prolog+                     test/cases/abc.python+                     test/cases/abc.r+                     test/cases/abc.ruby+                     test/cases/abc.scala+                     test/cases/abc.scheme+                     test/cases/abc.tcl+                     test/cases/archive.rhtml+                     test/cases/life.lua+                     test/cases/hk91.html+                     test/expected/abc.ada.native+                     test/expected/abc.agda.native+                     test/expected/abc.c.native+                     test/expected/abc.clojure.native+                     test/expected/abc.cpp.native+                     test/expected/abc.cs.native+                     test/expected/abc.d.native+                     test/expected/abc.fortran.native+                     test/expected/abc.go.native+                     test/expected/abc.haskell.native+                     test/expected/abc.java.native+                     test/expected/abc.javascript.native+                     test/expected/abc.julia.native+                     test/expected/abc.kotlin.native+                     test/expected/abc.lisp.native+                     test/expected/abc.matlab.native+                     test/expected/abc.ocaml.native+                     test/expected/abc.perl.native+                     test/expected/abc.php.native+                     test/expected/abc.prolog.native+                     test/expected/abc.python.native+                     test/expected/abc.r.native+                     test/expected/abc.ruby.native+                     test/expected/abc.scala.native+                     test/expected/abc.scheme.native+                     test/expected/abc.tcl.native+                     test/expected/archive.rhtml.native+                     test/expected/life.lua.native+                     test/expected/hk91.html.native++cabal-version:       >=1.10++source-repository head+  type:              git+  location:          https://github.com/jgm/skylighting.git++library+  exposed-modules:     Skylighting+                       Skylighting.Types+                       Skylighting.Regex+                       Skylighting.Parser+                       Skylighting.Styles+                       Skylighting.Tokenizer+                       Skylighting.Format.HTML+                       Skylighting.Format.LaTeX+                       Skylighting.Syntax+  other-modules:+                       Skylighting.Syntax.Abc+                       Skylighting.Syntax.Actionscript+                       Skylighting.Syntax.Ada+                       Skylighting.Syntax.Agda+                       Skylighting.Syntax.Alert+                       Skylighting.Syntax.AlertIndent+                       Skylighting.Syntax.Apache+                       Skylighting.Syntax.Asn1+                       Skylighting.Syntax.Asp+                       Skylighting.Syntax.Ats+                       Skylighting.Syntax.Awk+                       Skylighting.Syntax.Bash+                       Skylighting.Syntax.Bibtex+                       Skylighting.Syntax.Boo+                       Skylighting.Syntax.C+                       Skylighting.Syntax.Changelog+                       Skylighting.Syntax.Clojure+                       Skylighting.Syntax.Cmake+                       Skylighting.Syntax.Coffee+                       Skylighting.Syntax.Coldfusion+                       Skylighting.Syntax.Commonlisp+                       Skylighting.Syntax.Cpp+                       Skylighting.Syntax.Cs+                       Skylighting.Syntax.Css+                       Skylighting.Syntax.Curry+                       Skylighting.Syntax.D+                       Skylighting.Syntax.Diff+                       Skylighting.Syntax.Djangotemplate+                       Skylighting.Syntax.Dockerfile+                       Skylighting.Syntax.Dot+                       Skylighting.Syntax.Doxygen+                       Skylighting.Syntax.Doxygenlua+                       Skylighting.Syntax.Dtd+                       Skylighting.Syntax.Eiffel+                       Skylighting.Syntax.Elixir+                       Skylighting.Syntax.Email+                       Skylighting.Syntax.Erlang+                       Skylighting.Syntax.Fasm+                       Skylighting.Syntax.Fortran+                       Skylighting.Syntax.Fsharp+                       Skylighting.Syntax.Gcc+                       Skylighting.Syntax.Glsl+                       Skylighting.Syntax.Gnuassembler+                       Skylighting.Syntax.Go+                       Skylighting.Syntax.Hamlet+                       Skylighting.Syntax.Haskell+                       Skylighting.Syntax.Haxe+                       Skylighting.Syntax.Html+                       Skylighting.Syntax.Idris+                       Skylighting.Syntax.Ini+                       Skylighting.Syntax.Isocpp+                       Skylighting.Syntax.Java+                       Skylighting.Syntax.Javadoc+                       Skylighting.Syntax.Javascript+                       Skylighting.Syntax.Json+                       Skylighting.Syntax.Jsp+                       Skylighting.Syntax.Julia+                       Skylighting.Syntax.Kotlin+                       Skylighting.Syntax.Latex+                       Skylighting.Syntax.Lex+                       Skylighting.Syntax.Lilypond+                       Skylighting.Syntax.LiterateCurry+                       Skylighting.Syntax.LiterateHaskell+                       Skylighting.Syntax.Llvm+                       Skylighting.Syntax.Lua+                       Skylighting.Syntax.M4+                       Skylighting.Syntax.Makefile+                       Skylighting.Syntax.Mandoc+                       Skylighting.Syntax.Markdown+                       Skylighting.Syntax.Mathematica+                       Skylighting.Syntax.Matlab+                       Skylighting.Syntax.Maxima+                       Skylighting.Syntax.Mediawiki+                       Skylighting.Syntax.Metafont+                       Skylighting.Syntax.Mips+                       Skylighting.Syntax.Modelines+                       Skylighting.Syntax.Modula2+                       Skylighting.Syntax.Modula3+                       Skylighting.Syntax.Monobasic+                       Skylighting.Syntax.Nasm+                       Skylighting.Syntax.Noweb+                       Skylighting.Syntax.Objectivec+                       Skylighting.Syntax.Objectivecpp+                       Skylighting.Syntax.Ocaml+                       Skylighting.Syntax.Octave+                       Skylighting.Syntax.Opencl+                       Skylighting.Syntax.Pascal+                       Skylighting.Syntax.Perl+                       Skylighting.Syntax.Php+                       Skylighting.Syntax.Pike+                       Skylighting.Syntax.Postscript+                       Skylighting.Syntax.Prolog+                       Skylighting.Syntax.Pure+                       Skylighting.Syntax.Purebasic+                       Skylighting.Syntax.Python+                       Skylighting.Syntax.R+                       Skylighting.Syntax.Relaxng+                       Skylighting.Syntax.Relaxngcompact+                       Skylighting.Syntax.Rest+                       Skylighting.Syntax.Rhtml+                       Skylighting.Syntax.Roff+                       Skylighting.Syntax.Ruby+                       Skylighting.Syntax.Rust+                       Skylighting.Syntax.Scala+                       Skylighting.Syntax.Scheme+                       Skylighting.Syntax.Sci+                       Skylighting.Syntax.Sed+                       Skylighting.Syntax.Sgml+                       Skylighting.Syntax.SqlMysql+                       Skylighting.Syntax.SqlPostgresql+                       Skylighting.Syntax.Sql+                       Skylighting.Syntax.Tcl+                       Skylighting.Syntax.Tcsh+                       Skylighting.Syntax.Texinfo+                       Skylighting.Syntax.Verilog+                       Skylighting.Syntax.Vhdl+                       Skylighting.Syntax.Xml+                       Skylighting.Syntax.Xorg+                       Skylighting.Syntax.Xslt+                       Skylighting.Syntax.Xul+                       Skylighting.Syntax.Yacc+                       Skylighting.Syntax.Yaml+                       Skylighting.Syntax.Zsh+  other-extensions:    CPP, Arrows+  build-depends:       base >= 4.7 && < 5.0,+                       mtl,+                       text,+                       bytestring,+                       regex-pcre-builtin,+                       directory,+                       filepath,+                       aeson,+                       case-insensitive,+                       utf8-string,+                       hxt,+                       safe,+                       blaze-html >= 0.5,+                       containers+  hs-source-dirs:      src+  if impl(ghc < 7.10)+     hs-source-dirs:   prelude+     other-modules:    Prelude+  default-language:    Haskell2010+  ghc-options:         -Wall+  if flag(bootstrap)+    buildable:         False++Flag bootstrap+  Description:   Only build skylighting-extract+  Default:       False++Flag executable+  Description:   Build skylighting CLI tool+  Default:       False++executable skylighting-extract+  build-depends:       base >= 4.7 && < 5.0,+                       filepath,+                       bytestring,+                       text,+                       regex-pcre-builtin,+                       safe,+                       hxt,+                       utf8-string,+                       case-insensitive,+                       aeson,+                       pretty-show,+                       containers,+                       directory+  hs-source-dirs:      bin, src+  if impl(ghc < 7.10)+     hs-source-dirs:   prelude+     other-modules:    Prelude+  main-is:             extract.hs+  default-language:    Haskell2010+  other-extensions:    CPP+  ghc-options:         -Wall+  other-modules:       Skylighting.Types+                       Skylighting.Regex+                       Skylighting.Parser+  if flag(bootstrap)+    buildable:         True+  else+    buildable:         False++executable skylighting+  build-depends:       base >= 4.7 && < 5.0,+                       filepath,+                       text,+                       pretty-show,+                       containers,+                       directory,+                       bytestring,+                       blaze-html >= 0.5,+                       skylighting+  hs-source-dirs:      bin+  if impl(ghc < 7.10)+     hs-source-dirs:   prelude+     other-modules:    Prelude+  main-is:             main.hs+  default-language:    Haskell2010+  other-extensions:    CPP+  ghc-options:         -Wall+  if flag(bootstrap)+    buildable:         False+  if flag(executable)+    buildable:         True+  else+    buildable:         False++test-suite test-skylighting+  type:           exitcode-stdio-1.0+  main-is:        test-skylighting.hs+  hs-source-dirs: test+  if impl(ghc < 7.10)+     hs-source-dirs:   prelude+     other-modules:    Prelude+  build-depends:  base >= 4.7 && < 5.0,+                  HUnit,+                  tasty,+                  tasty-golden,+                  tasty-hunit,+                  Diff,+                  text,+                  pretty-show,+                  aeson,+                  bytestring,+                  directory,+                  filepath,+                  QuickCheck,+                  skylighting+  default-language: Haskell2010+  ghc-options:    -Wall+  if flag(bootstrap)+    buildable:         False+
+ src/Skylighting.hs view
@@ -0,0 +1,75 @@+module Skylighting (+    lookupSyntax+  , syntaxByName+  , syntaxByShortName+  , syntaxesByExtension+  , syntaxesByFilename+  , module Skylighting.Types+  , module Skylighting.Tokenizer+  , module Skylighting.Parser+  , module Skylighting.Regex+  , module Skylighting.Syntax+  , module Skylighting.Styles+  , module Skylighting.Format.HTML+  , module Skylighting.Format.LaTeX+  ) where+import Control.Monad+import Data.List (tails)+import qualified Data.Map as Map+import Data.Maybe (listToMaybe)+import Data.Text (Text)+import qualified Data.Text as Text+import Skylighting.Format.HTML+import Skylighting.Format.LaTeX+import Skylighting.Parser+import Skylighting.Regex+import Skylighting.Styles+import Skylighting.Syntax+import Skylighting.Tokenizer+import Skylighting.Types++-- | Returns a list of syntaxes appropriate for the given file extension.+syntaxesByExtension :: SyntaxMap -> String -> [Syntax]+syntaxesByExtension syntaxmap ('.':ext) =+  syntaxesByFilename syntaxmap ("*." ++ ext)+syntaxesByExtension syntaxmap ext =+  syntaxesByFilename syntaxmap ("*." ++ ext)++-- | Returns a list of syntaxes appropriate for the given filename.+syntaxesByFilename :: SyntaxMap -> String -> [Syntax]+syntaxesByFilename syntaxmap fn = [s | s <- Map.elems syntaxmap+                                , matchGlobs fn (sExtensions s)]++-- | Lookup a syntax by full name (case insensitive).+syntaxByName :: SyntaxMap -> Text -> Maybe Syntax+syntaxByName syntaxmap name =+  Map.lookup (Text.toLower name) (Map.mapKeys Text.toLower syntaxmap)++-- | Lookup a syntax by short name (case insensitive).+syntaxByShortName :: SyntaxMap -> Text -> Maybe Syntax+syntaxByShortName syntaxmap name = listToMaybe+  [s | s <- Map.elems syntaxmap+     , Text.toLower (sShortname s) == Text.toLower name ]++-- | Lookup syntax by (in order) full name (case insensitive),+-- short name (case insensitive), extension.+lookupSyntax :: Text -> SyntaxMap -> Maybe Syntax+lookupSyntax lang syntaxmap+  -- special cases:+  | lang == Text.pack "csharp" = lookupSyntax (Text.pack "cs") syntaxmap+  | otherwise =+    syntaxByName syntaxmap lang `mplus`+    syntaxByShortName syntaxmap lang `mplus`+    listToMaybe (syntaxesByExtension syntaxmap (Text.unpack lang))++-- | Match filename against a list of globs contained in a semicolon-separated+-- string.+matchGlobs :: String -> [String] -> Bool+matchGlobs fn globs = any (flip matchGlob fn) globs++-- | Match filename against a glob pattern with asterisks.+matchGlob :: String -> String -> Bool+matchGlob ('*':xs) fn   = any (matchGlob xs) (tails fn)+matchGlob (x:xs) (y:ys) = x == y && matchGlob xs ys+matchGlob "" ""         = True+matchGlob _ _           = False
+ src/Skylighting/Format/HTML.hs view
@@ -0,0 +1,167 @@+module Skylighting.Format.HTML (+      formatHtmlInline+    , formatHtmlBlock+    , styleToCss+    ) where++import Data.List (intersperse)+import qualified Data.Text as Text+import Skylighting.Types+import Text.Blaze.Html+import qualified Text.Blaze.Html5 as H+import qualified Text.Blaze.Html5.Attributes as A++-- | Format tokens using HTML spans inside @code@ tags. For example,+-- A @KeywordTok@ is rendered as a span with class @kw@.+-- Short class names correspond to 'TokenType's as follows:+-- 'KeywordTok'        = @kw@,+-- 'DataTypeTok'       = @dt@,+-- 'DecValTok'         = @dv@,+-- 'BaseNTok'          = @bn@,+-- 'FloatTok'          = @fl@,+-- 'CharTok'           = @ch@,+-- 'StringTok'         = @st@,+-- 'CommentTok'        = @co@,+-- 'OtherTok'          = @ot@,+-- 'AlertTok'          = @al@,+-- 'FunctionTok'       = @fu@,+-- 'RegionMarkerTok'   = @re@,+-- 'ErrorTok'          = @er@,+-- 'ConstantTok'       = @cn@,+-- 'SpecialCharTok'    = @sc@,+-- 'VerbatimStringTok' = @vs@,+-- 'SpecialStringTok'  = @ss@,+-- 'ImportTok'         = @im@,+-- 'DocumentationTok'  = @do@,+-- 'AnnotationTok'     = @an@,+-- 'CommentVarTok'     = @cv@,+-- 'VariableTok'       = @va@,+-- 'ControlFlowTok'    = @cf@,+-- 'OperatorTok'       = @op@,+-- 'BuiltInTok'        = @bu@,+-- 'ExtensionTok'      = @ex@,+-- 'PreprocessorTok'   = @pp@,+-- 'AttributeTok'      = @at@,+-- 'InformationTok'    = @in@,+-- 'WarningTok'        = @wa@.+-- A 'NormalTok' is not marked up at all.+formatHtmlInline :: FormatOptions -> [SourceLine] -> Html+formatHtmlInline opts = (H.code ! A.class_ (toValue $ Text.unwords+                                                    $ Text.pack "sourceCode"+                                                      : codeClasses opts))+                                . mconcat . intersperse (toHtml "\n")+                                . map (sourceLineToHtml opts)++tokenToHtml :: FormatOptions -> Token -> Html+tokenToHtml _ (NormalTok, txt)  = toHtml txt+tokenToHtml opts (toktype, txt) =+  if titleAttributes opts+     then sp ! A.title (toValue $ show toktype)+     else sp+   where sp = H.span ! A.class_ (toValue $ short toktype) $ toHtml txt++short :: TokenType -> String+short KeywordTok        = "kw"+short DataTypeTok       = "dt"+short DecValTok         = "dv"+short BaseNTok          = "bn"+short FloatTok          = "fl"+short CharTok           = "ch"+short StringTok         = "st"+short CommentTok        = "co"+short OtherTok          = "ot"+short AlertTok          = "al"+short FunctionTok       = "fu"+short RegionMarkerTok   = "re"+short ErrorTok          = "er"+short ConstantTok       = "cn"+short SpecialCharTok    = "sc"+short VerbatimStringTok = "vs"+short SpecialStringTok  = "ss"+short ImportTok         = "im"+short DocumentationTok  = "do"+short AnnotationTok     = "an"+short CommentVarTok     = "cv"+short VariableTok       = "va"+short ControlFlowTok    = "cf"+short OperatorTok       = "op"+short BuiltInTok        = "bu"+short ExtensionTok      = "ex"+short PreprocessorTok   = "pp"+short AttributeTok      = "at"+short InformationTok    = "in"+short WarningTok        = "wa"+short NormalTok         = ""++sourceLineToHtml :: FormatOptions -> SourceLine -> Html+sourceLineToHtml opts cont = mapM_ (tokenToHtml opts) cont++formatHtmlBlockPre :: FormatOptions -> [SourceLine] -> Html+formatHtmlBlockPre opts = H.pre . formatHtmlInline opts++-- | Format tokens as an HTML @pre@ block. If line numbering is+-- selected, this is put into a table row with line numbers in the+-- left cell.  The whole code block is wrapped in a @div@ element+-- to aid styling (e.g. the overflow-x property).  See the+-- documentation for 'formatHtmlInline' for information about how+-- tokens are encoded.+formatHtmlBlock :: FormatOptions -> [SourceLine] -> Html+formatHtmlBlock opts ls = H.div ! A.class_ sourceCode $+                            container ! A.class_ (toValue $ Text.unwords classes)+  where  container = if numberLines opts+                        then H.table $ H.tr ! A.class_ sourceCode $+                                 nums >> source+                        else pre+         sourceCode = toValue "sourceCode"+         classes = Text.pack "sourceCode" :+                   [x | x <- containerClasses opts, x /= Text.pack "sourceCode"]+         pre = formatHtmlBlockPre opts ls+         source = H.td ! A.class_ sourceCode $ pre+         startNum = startNumber opts+         nums = H.td ! A.class_ (toValue "lineNumbers")+                     $ H.pre+                     $ mapM_ lineNum [startNum..(startNum + length ls - 1)]+         lineNum n = if lineAnchors opts+                        then (H.a ! A.id (toValue nStr) ! A.href (toValue $ "#" ++ nStr) $ toHtml $ show n)+                              >> toHtml "\n"+                        else toHtml $ show n ++ "\n"+           where nStr = show n++-- | Returns CSS for styling highlighted code according to the given style.+styleToCss :: Style -> String+styleToCss f = unlines $ divspec ++ tablespec ++ colorspec ++ map toCss (tokenStyles f)+   where colorspec = case (defaultColor f, backgroundColor f) of+                          (Nothing, Nothing) -> []+                          (Just c, Nothing)  -> ["pre, code { color: " ++ fromColor c ++ "; }"]+                          (Nothing, Just c)  -> ["pre, code { background-color: " ++ fromColor c ++ "; }"]+                          (Just c1, Just c2) -> ["pre, code { color: " ++ fromColor c1 ++ "; background-color: " +++                                                  fromColor c2 ++ "; }"]+         tablespec = [+           "table.sourceCode, tr.sourceCode, td.lineNumbers, td.sourceCode {"+          ,"  margin: 0; padding: 0; vertical-align: baseline; border: none; }"+          ,"table.sourceCode { width: 100%; line-height: 100%; " +++             maybe "" (\c -> "background-color: " ++ fromColor c ++ "; ") (backgroundColor f) +++             maybe "" (\c -> "color: " ++ fromColor c ++ "; ") (defaultColor f) +++             "}"+          ,"td.lineNumbers { text-align: right; padding-right: 4px; padding-left: 4px; " +++             maybe "" (\c -> "background-color: " ++ fromColor c ++ "; ") (lineNumberBackgroundColor f) +++             maybe "" (\c -> "color: " ++ fromColor c ++ "; ") (lineNumberColor f) +++             maybe "" (\c -> "border-right: 1px solid " ++ fromColor c ++ "; ") (lineNumberColor f) +++             "}"+          ,"td.sourceCode { padding-left: 5px; }"+          ]+         divspec = [ "div.sourceCode { overflow-x: auto; }" ]++toCss :: (TokenType, TokenStyle) -> String+toCss (t,tf) = "code > span." ++ short t ++ " { "+                ++ colorspec ++ backgroundspec ++ weightspec ++ stylespec+                ++ decorationspec ++ "} /* " ++ showTokenType t ++ " */"+  where colorspec = maybe "" (\col -> "color: " ++ fromColor col ++ "; ") $ tokenColor tf+        backgroundspec = maybe "" (\col -> "background-color: " ++ fromColor col ++ "; ") $ tokenBackground tf+        weightspec = if tokenBold tf then "font-weight: bold; " else ""+        stylespec  = if tokenItalic tf then "font-style: italic; " else ""+        decorationspec = if tokenUnderline tf then "text-decoration: underline; " else ""+        showTokenType t' = case reverse (show t') of+                             'k':'o':'T':xs -> reverse xs+                             _              -> ""+
+ src/Skylighting/Format/LaTeX.hs view
@@ -0,0 +1,131 @@+{-# LANGUAGE OverloadedStrings   #-}+{-# LANGUAGE ScopedTypeVariables #-}+module Skylighting.Format.LaTeX (+         formatLaTeXInline+       , formatLaTeXBlock+       , styleToLaTeX+       ) where++import Control.Monad (mplus)+import Data.Char (isSpace)+import Data.Monoid+import Data.Text (Text)+import qualified Data.Text as Text+import Skylighting.Types+import Text.Printf++formatLaTeX :: Bool -> [SourceLine] -> Text+formatLaTeX inline = Text.intercalate (Text.singleton '\n')+                       . map (sourceLineToLaTeX inline)++-- | Formats tokens as LaTeX using custom commands inside+-- @|@ characters. Assumes that @|@ is defined as a short verbatim+-- command by the macros produced by 'styleToLaTeX'.+-- A @KeywordTok@ is rendered using @\\KeywordTok{..}@, and so on.+formatLaTeXInline :: FormatOptions -> [SourceLine] -> Text+formatLaTeXInline _opts ls = "\\VERB|" <> formatLaTeX True ls <> "|"++sourceLineToLaTeX :: Bool -> SourceLine -> Text+sourceLineToLaTeX inline = mconcat . map (tokenToLaTeX inline)++tokenToLaTeX :: Bool -> Token -> Text+tokenToLaTeX inline (NormalTok, txt)+  | Text.all isSpace txt = escapeLaTeX inline txt+tokenToLaTeX inline (toktype, txt)   = Text.snoc+  (Text.pack (show toktype) <> "{" <> escapeLaTeX inline txt <> "}") '\\'++escapeLaTeX :: Bool -> Text -> Text+escapeLaTeX inline = Text.concatMap escapeLaTeXChar+  where escapeLaTeXChar '\\' = "\\textbackslash{}"+        escapeLaTeXChar '{'  = "\\{"+        escapeLaTeXChar '}'  = "\\}"+        escapeLaTeXChar '|'  = if inline+                                  then "\\VerbBar{}" -- used in inline verbatim+                                  else "|"+        escapeLaTeXChar x    = Text.singleton x++-- LaTeX++-- | Format tokens as a LaTeX @Highlighting@ environment inside a+-- @Shaded@ environment.  @Highlighting@ and @Shaded@ are+-- defined by the macros produced by 'styleToLaTeX'.  @Highlighting@+-- is a verbatim environment using @fancyvrb@; @\\@, @{@, and @}@+-- have their normal meanings inside this environment, so that+-- formatting commands work.  @Shaded@ is either nothing+-- (if the style's background color is default) or a @snugshade@+-- environment from @framed@, providing a background color+-- for the whole code block, even if it spans multiple pages.+formatLaTeXBlock :: FormatOptions -> [SourceLine] -> Text+formatLaTeXBlock opts ls = Text.unlines+  ["\\begin{Shaded}"+  ,"\\begin{Highlighting}[" <>+   (if numberLines opts+       then "numbers=left," <>+            (if startNumber opts == 1+                then ""+                else ",firstnumber=" <>+                     Text.pack (show (startNumber opts))) <> ","+       else Text.empty) <> "]"+  ,formatLaTeX False ls+  ,"\\end{Highlighting}"+  ,"\\end{Shaded}"]++-- | Converts a 'Style' to a set of LaTeX macro definitions,+-- which should be placed in the document's preamble.+-- Note: default LaTeX setup doesn't allow boldface typewriter font.+-- To make boldface work in styles, you need to use a different typewriter+-- font. This will work for computer modern:+--+-- > \DeclareFontShape{OT1}{cmtt}{bx}{n}{<5><6><7><8><9><10><10.95><12><14.4><17.28><20.74><24.88>cmttb10}{}+--+-- Or, with xelatex:+--+-- > \usepackage{fontspec}+-- > \setmainfont[SmallCapsFont={* Caps}]{Latin Modern Roman}+-- > \setsansfont{Latin Modern Sans}+-- > \setmonofont[SmallCapsFont={Latin Modern Mono Caps}]{Latin Modern Mono Light}+--+styleToLaTeX :: Style -> Text+styleToLaTeX f = Text.unlines $+  [ "\\usepackage{color}"+  , "\\usepackage{fancyvrb}"+  , "\\newcommand{\\VerbBar}{|}"+  , "\\newcommand{\\VERB}{\\Verb[commandchars=\\\\\\{\\}]}"+  , "\\DefineVerbatimEnvironment{Highlighting}{Verbatim}{commandchars=\\\\\\{\\}}"+  , "% Add ',fontsize=\\small' for more characters per line"+  ] +++  (case backgroundColor f of+        Nothing          -> ["\\newenvironment{Shaded}{}{}"]+        Just (RGB r g b) -> ["\\usepackage{framed}"+                            ,Text.pack+                              (printf "\\definecolor{shadecolor}{RGB}{%d,%d,%d}" r g b)+                            ,"\\newenvironment{Shaded}{\\begin{snugshade}}{\\end{snugshade}}"])+  ++ map (macrodef (defaultColor f) (tokenStyles f)) (enumFromTo KeywordTok NormalTok)++macrodef :: Maybe Color -> [(TokenType, TokenStyle)] -> TokenType -> Text+macrodef defaultcol tokstyles tokt = "\\newcommand{\\" <> Text.pack (show tokt) <>+                     "}[1]{" <> (co . ul . bf . it . bg $ "{#1}") <> "}"+  where tokf = case lookup tokt tokstyles of+                     Nothing -> defStyle+                     Just x  -> x+        ul x = if tokenUnderline tokf+                  then "\\underline{" <> x <> "}"+                  else x+        it x = if tokenItalic tokf+                  then "\\textit{" <> x <> "}"+                  else x+        bf x = if tokenBold tokf+                  then "\\textbf{" <> x <> "}"+                  else x+        bcol = fromColor `fmap` tokenBackground tokf :: Maybe (Double, Double, Double)+        bg x = case bcol of+                    Nothing          -> x+                    Just (r, g, b) -> Text.pack $+                       printf "\\colorbox[rgb]{%0.2f,%0.2f,%0.2f}{%s}" r g b x+        col  = fromColor `fmap`+                 (tokenColor tokf `mplus` defaultcol) :: Maybe (Double, Double, Double)+        co x = case col of+                    Nothing        -> x+                    Just (r, g, b) -> Text.pack $+                        printf "\\textcolor[rgb]{%0.2f,%0.2f,%0.2f}{%s}" r g b x+
+ src/Skylighting/Parser.hs view
@@ -0,0 +1,346 @@+{-# LANGUAGE Arrows #-}+module Skylighting.Parser ( parseSyntaxDefinition+                          , addSyntaxDefinition+                          , missingIncludes+                          ) where++import Data.ByteString.UTF8 (fromString)+import Data.Char (isAlphaNum, toUpper)+import Data.List (nub)+import qualified Data.Map as Map+import Data.Maybe (fromMaybe)+import qualified Data.Set as Set+import Data.Text (Text)+import qualified Data.Text as Text+import Safe+import Skylighting.Regex+import Skylighting.Types+import System.FilePath+import Text.XML.HXT.Core++-- | Adds a syntax definition to a syntax map,+-- replacing any existing definition with the same name.+addSyntaxDefinition :: Syntax -> SyntaxMap -> SyntaxMap+addSyntaxDefinition s = Map.insert (sName s) s++-- | Scan a list of 'Syntax's and make sure that+-- `IncludeRules` never asks for a syntax not in this+-- list.  Produces a list of pairs where the first+-- element is the including syntax name and the second+-- element is the (missing) included syntax name.+-- This is intended for sanity checks to avoid run-time+-- errors.+missingIncludes :: [Syntax] -> [(Text, Text)]+missingIncludes syns = nub+  [(sName s, lang)+     | s <- syns+     , c <- Map.elems (sContexts s)+     , IncludeRules (lang, _) <- map rMatcher (cRules c)+     , lang `notElem` (map sName syns)]++standardDelims :: Set.Set Char+standardDelims = Set.fromList " \n\t.():!+,-<=>%&*/;?[]^{|}~\\"++defaultKeywordAttr :: KeywordAttr+defaultKeywordAttr = KeywordAttr { keywordCaseSensitive = True+                                 , keywordDelims = standardDelims }++stripWhitespace :: String -> String+stripWhitespace = reverse . stripWhitespaceLeft . reverse . stripWhitespaceLeft+  where stripWhitespaceLeft = dropWhile isWhitespace+        isWhitespace x = x `elem` [' ', '\t', '\n']++vBool :: Bool -> String -> Bool+vBool defaultVal value = case value of+                           z | z `elem` ["true","yes","1"] -> True+                           z | z `elem` ["false","no","0"] -> False+                           _ -> defaultVal++-- | Parses a file containing a Kate XML syntax definition+-- into a 'Syntax' description.+parseSyntaxDefinition :: String -> IO (Either String Syntax)+parseSyntaxDefinition xml = do+  res <- runX (application xml)+  case res of+       [s] -> return $ Right s+       _   -> return $ Left $ "Could not parse syntax definition " ++ xml++application :: String -> IOSArrow b Syntax+application fp+    = readDocument [withValidate no, withInputEncoding utf8] fp+      >>>+      multi (hasName "language")+      >>>+      extractSyntaxDefinition (takeFileName fp)++extractSyntaxDefinition :: String -> IOSArrow XmlTree Syntax+extractSyntaxDefinition filename =+  proc x -> do+     lang <- getAttrValue "name" -< x+     author <- getAttrValue "author" -< x+     version <- getAttrValue "version" -< x+     license <- getAttrValue "license" -< x+     extensions <- getAttrValue "extensions" -< x+     contexts <- getContexts $<+                    (arr (vBool True) <<< getAttrValue "casesensitive") &&&+                    (getAttrValue "name") &&&+                    (arr toItemDataTable <<< getItemDatas) &&&+                    getLists &&&+                    (arr (headDef defaultKeywordAttr) <<< getKeywordAttrs) -< x+     startingContext <- case contexts of+                             (c:_) -> returnA -< cName c+                             []    -> issueErr "No contexts" >>> none -< ()+     returnA -< Syntax{+                  sName     = Text.pack lang+                , sFilename = filename+                , sShortname = Text.pack $ pathToLangName filename+                , sAuthor   = Text.pack $ author+                , sVersion  = Text.pack $ version+                , sLicense  = Text.pack $ license+                , sExtensions = words $ map+                     (\c -> if c == ';'+                               then ' '+                               else c) extensions+                , sContexts = Map.fromList+                       [(cName c, c) | c <- contexts]+                , sStartingContext = startingContext+                }++toItemDataTable :: [(String,String)] -> Map.Map String TokenType+toItemDataTable = Map.fromList . map (\(s,t) -> (s, toTokenType t))++getItemDatas :: IOSArrow XmlTree [(String,String)]+getItemDatas =+  multi (hasName "itemDatas")+     >>>+     (listA $ getChildren+             >>>+             hasName "itemData"+             >>>+             getAttrValue "name" &&& getAttrValue "defStyleNum")++toTokenType :: String -> TokenType+toTokenType s =+  case s of+       "dsNormal"         -> NormalTok+       "dsKeyword"        -> KeywordTok+       "dsDataType"       -> DataTypeTok+       "dsDecVal"         -> DecValTok+       "dsBaseN"          -> BaseNTok+       "dsFloat"          -> FloatTok+       "dsConstant"       -> ConstantTok+       "dsChar"           -> CharTok+       "dsSpecialChar"    -> SpecialCharTok+       "dsString"         -> StringTok+       "dsVerbatimString" -> VerbatimStringTok+       "dsSpecialString"  -> SpecialStringTok+       "dsImport"         -> ImportTok+       "dsComment"        -> CommentTok+       "dsDocumentation"  -> DocumentationTok+       "dsAnnotation"     -> AnnotationTok+       "dsCommentVar"     -> CommentVarTok+       "dsOthers"         -> OtherTok+       "dsFunction"       -> FunctionTok+       "dsVariable"       -> VariableTok+       "dsControlFlow"    -> ControlFlowTok+       "dsOperator"       -> OperatorTok+       "dsBuiltIn"        -> BuiltInTok+       "dsExtension"      -> ExtensionTok+       "dsPreprocessor"   -> PreprocessorTok+       "dsAttribute"      -> AttributeTok+       "dsRegionMarker"   -> RegionMarkerTok+       "dsInformation"    -> InformationTok+       "dsWarning"        -> WarningTok+       "dsAlert"          -> AlertTok+       "dsError"          -> ErrorTok+       _                  -> NormalTok++getLists :: IOSArrow XmlTree [(String, [String])]+getLists =+  listA $ multi (hasName "list")+     >>>+     getAttrValue "name" &&& getListContents++getListContents :: IOSArrow XmlTree [String]+getListContents =+  listA $ getChildren+     >>>+     hasName "item"+     >>>+     getChildren+     >>>+     getText+     >>>+     arr stripWhitespace++getContexts ::+     (Bool,+       (String,+         (Map.Map String TokenType,+           ([(String, [String])], KeywordAttr))))+            -> IOSArrow XmlTree [Context]+getContexts (casesensitive, (syntaxname, (itemdatas, (lists, kwattr)))) =+  listA $ multi (hasName "context")+     >>>+     proc x -> do+       name <- getAttrValue "name" -< x+       attribute <- getAttrValue "attribute" -< x+       lineEmptyContext <- getAttrValue "lineEmptyContext" -< x+       lineEndContext <- getAttrValue "lineEndContext" -< x+       lineBeginContext <- getAttrValue "lineBeginContext" -< x+       fallthrough <- arr (vBool False) <<< getAttrValue "fallthrough" -< x+       fallthroughContext <- getAttrValue "fallthroughContext" -< x+       dynamic <- arr (vBool False) <<< getAttrValue "dynamic" -< x+       parsers <- getParsers (casesensitive, (syntaxname,+                                (itemdatas, (lists, kwattr)))) $<+                            getAttrValue "attribute" -< x+       returnA -< Context {+                     cName = Text.pack name+                   , cSyntax = Text.pack syntaxname+                   , cRules = parsers+                   , cAttribute = fromMaybe NormalTok $+                           Map.lookup attribute itemdatas+                   , cLineEmptyContext =+                        parseContextSwitch syntaxname lineEmptyContext+                   , cLineEndContext =+                        parseContextSwitch syntaxname lineEndContext+                   , cLineBeginContext =+                        parseContextSwitch syntaxname lineBeginContext+                   , cFallthrough = fallthrough+                   , cFallthroughContext =+                        parseContextSwitch syntaxname fallthroughContext+                   , cDynamic = dynamic+                   }++-- Note, some xml files have "\\" for a backslash,+-- others have "\".  Not sure what the rules are, but+-- this covers both bases:+readChar :: String -> Char+readChar s = case s of+                  [c] -> c+                  _   -> readDef '\xffff' $ "'" ++ s ++ "'"+++getParsers :: (Bool,+                (String,+                  (Map.Map String TokenType,+                    ([(String, [String])], KeywordAttr))))+            -> String  -- context attribute+            -> IOSArrow XmlTree [Rule]+getParsers (casesensitive, (syntaxname, (itemdatas, (lists, kwattr)))) cattr =+  listA $ getChildren+     >>>+     proc x -> do+       name <- getName -< x+       attribute <- getAttrValue "attribute" -< x+       context <- getAttrValue "context" -< x+       char0 <- arr readChar <<< getAttrValue "char" -< x+       char1 <- arr readChar <<< getAttrValue "char1" -< x+       str' <- getAttrValue "String" -< x+       insensitive <- arr (vBool (not casesensitive))+                            <<< getAttrValue "insensitive" -< x+       includeAttrib <- arr (vBool False) <<< getAttrValue "includeAttrib" -< x+       lookahead <- arr (vBool False) <<< getAttrValue "lookAhead" -< x+       firstNonSpace <- arr (vBool False) <<< getAttrValue "firstNonSpace" -< x+       column' <- getAttrValue "column" -< x+       dynamic <- arr (vBool False) <<< getAttrValue "dynamic" -< x+       children <- getParsers+                     (casesensitive, (syntaxname, (itemdatas, (lists, kwattr))))+                     cattr -< x+       let tildeRegex = name == "RegExpr" && take 1 str' == "^"+       let str = if tildeRegex then drop 1 str' else str'+       let column = if tildeRegex+                       then Just (0 :: Int)+                       else readMay column'+       let compiledRe = if dynamic+                           then Nothing+                           else Just $ compileRegex True (fromString str)+       let re = RegExpr RE{ reString = fromString $ convertOctalEscapes str+                          , reCompiled = compiledRe+                          , reCaseSensitive = not insensitive }+       let (incsyntax, inccontext) =+               case break (=='#') context of+                     (cont, '#':'#':lang) -> (lang, cont)+                     _                    -> (syntaxname, context)+       let mbmatcher = case name of+                         "DetectChar" -> Just $ DetectChar char0+                         "Detect2Chars" -> Just $ Detect2Chars char0 char1+                         "AnyChar" -> Just $ AnyChar str+                         "RangeDetect" -> Just $ RangeDetect char0 char1+                         "StringDetect" -> Just $ StringDetect $ Text.pack str+                         "WordDetect" -> Just $ WordDetect $ Text.pack str+                         "RegExpr" -> Just $ re+                         "keyword" -> Just $ Keyword kwattr $+                            maybe (makeWordSet True [])+                              (makeWordSet (keywordCaseSensitive kwattr) . map Text.pack)+                              (lookup str lists)+                         "Int" -> Just $ Int+                         "Float" -> Just $ Float+                         "HlCOct" -> Just $ HlCOct+                         "HlCHex" -> Just $ HlCHex+                         "HlCStringChar" -> Just $ HlCStringChar+                         "HlCChar" -> Just $ HlCChar+                         "LineContinue" -> Just $ LineContinue+                         "IncludeRules" -> Just $+                           IncludeRules (Text.pack incsyntax, Text.pack inccontext)+                         "DetectSpaces" -> Just $ DetectSpaces+                         "DetectIdentifier" -> Just $ DetectIdentifier+                         _ -> Nothing++       matcher <- case mbmatcher of+                       Nothing -> none+                                   <<< applyA (arr issueWarn)+                                   <<< arr ("Unknown element " ++)+                                   <<< getName -< x+                       Just m  -> returnA -< m++       let contextSwitch = if name == "IncludeRules"+                              then []  -- is this right?+                              else parseContextSwitch syntaxname context+       returnA -< Rule{ rMatcher = matcher,+                        rAttribute = fromMaybe NormalTok $+                           if null attribute+                              then Map.lookup cattr itemdatas+                              else Map.lookup attribute itemdatas,+                        rIncludeAttribute = includeAttrib,+                        rDynamic = dynamic,+                        rCaseSensitive = not insensitive,+                        rChildren = children,+                        rContextSwitch = contextSwitch,+                        rLookahead = lookahead,+                        rFirstNonspace = firstNonSpace ,+                        rColumn = column }++parseContextSwitch :: String -> String -> [ContextSwitch]+parseContextSwitch _ [] = []+parseContextSwitch _ "#stay" = []+parseContextSwitch syntaxname ('#':'p':'o':'p':xs) =+  Pop : parseContextSwitch syntaxname xs+parseContextSwitch syntaxname ('!':xs) = [Push (Text.pack syntaxname, Text.pack xs)]+parseContextSwitch syntaxname xs = [Push (Text.pack syntaxname, Text.pack xs)]++getKeywordAttrs :: IOSArrow XmlTree [KeywordAttr]+getKeywordAttrs =+  listA $ multi $ hasName "keywords"+     >>>+     proc x -> do+       caseSensitive <- arr (vBool True) <<< getAttrValue "casesensitive" -< x+       weakDelim <- getAttrValue "weakDeliminator" -< x+       additionalDelim <- getAttrValue "additionalDeliminator" -< x+       returnA -< KeywordAttr+                         { keywordCaseSensitive = caseSensitive+                         , keywordDelims = (Set.union standardDelims+                             (Set.fromList additionalDelim)) Set.\\+                                Set.fromList weakDelim }++pathToLangName :: String -> String+pathToLangName s = capitalize (camelize (takeBaseName s))++camelize :: String -> String+camelize (d:c:cs) | not (isAlphaNum d) = toUpper c : camelize cs+camelize (c:cs)   = c : camelize cs+camelize []       = []++capitalize :: String -> String+capitalize (c:cs) = toUpper c : cs+capitalize []     = []
+ src/Skylighting/Regex.hs view
@@ -0,0 +1,93 @@+{-# LANGUAGE DeriveDataTypeable  #-}+{-# LANGUAGE DeriveGeneric       #-}+{-# LANGUAGE ScopedTypeVariables #-}++module Skylighting.Regex (+                Regex+              , RegexException+              , RE(..)+              , compileRegex+              , matchRegex+              , convertOctalEscapes+              ) where++import qualified Control.Exception as E+import qualified Data.ByteString.Char8 as BS+import Data.ByteString.UTF8 (toString)+import GHC.Generics (Generic)+import System.IO.Unsafe (unsafePerformIO)+import Text.Printf+import Text.Regex.PCRE.ByteString+import Data.Typeable++newtype RegexException = RegexException String+      deriving (Show, Typeable, Generic)++instance E.Exception RegexException++data RE = RE{+    reString        :: BS.ByteString+  , reCompiled      :: Maybe Regex+  , reCaseSensitive :: Bool+}++instance Show RE where+  show re = "RE{ reString = " ++ show (reString re) +++            ", reCompiled = " +++            (case reCompiled re of+                  Nothing  -> "Nothing"+                  Just _   -> "Just (compileRegex " +++                                show (reCaseSensitive re) +++                                " " ++ show (reString re)+                                ++ ")") +++            ", reCaseSensitive = " ++ show (reCaseSensitive re) ++ "}"++-- | Compile a PCRE regex.  If the first parameter is True, the regex is+-- case-sensitive, otherwise caseless.  The regex is compiled from+-- a bytestring interpreted as UTF-8.  If the regex cannot be compiled,+-- a 'RegexException' is thrown.+compileRegex :: Bool -> BS.ByteString -> Regex+compileRegex caseSensitive regexpStr =+  let opts = compAnchored + compUTF8 ++               if caseSensitive then 0 else compCaseless+  in  case unsafePerformIO $ compile opts (execNotEmpty)+             (BS.cons '.' regexpStr) of+            Left (off,msg) -> E.throw $ RegexException $+                        "Error compiling regex /" ++ toString regexpStr +++                        "/ at offset " ++ show off ++ "\n" ++ msg+            Right r -> r++-- | Convert octal escapes to the form pcre wants.  Note:+-- need at least pcre 8.34 for the form \o{dddd}.+-- So we prefer \ddd or \x{...}.+convertOctalEscapes :: String -> String+convertOctalEscapes [] = ""+convertOctalEscapes ('\\':'0':x:y:z:rest)+  | all isOctalDigit [x,y,z] = '\\':x:y:z: convertOctalEscapes rest+convertOctalEscapes ('\\':x:y:z:rest)+  | all isOctalDigit [x,y,z] ='\\':x:y:z: convertOctalEscapes rest+convertOctalEscapes ('\\':'o':'{':zs) =+  case break (=='}') zs of+       (ds, '}':rest) | all isOctalDigit ds && not (null ds) ->+            case reads ('0':'o':ds) of+                 ((n :: Int,[]):_) ->+                     printf "\\x{%x}" n ++ convertOctalEscapes rest+                 _          -> E.throw $ RegexException $+                                   "Unable to read octal number: " ++ ds+       _  -> '\\':'o':'{': convertOctalEscapes zs+convertOctalEscapes (x:xs) = x : convertOctalEscapes xs++isOctalDigit :: Char -> Bool+isOctalDigit c = c >= '0' && c <= '7'++-- Match a 'Regex' against a bytestring.  Returns 'Nothing' if+-- no match, otherwise 'Just' a nonempty list of bytestrings. The first+-- bytestring in the list is the match, the others the captures, if any.+-- If there are errors in executing the regex, a 'RegexException' is+-- thrown.+matchRegex :: Regex -> BS.ByteString -> Maybe [BS.ByteString]+matchRegex r s = case unsafePerformIO (regexec r s) of+                      Right (Just (_, mat, _ , capts)) ->+                                       Just (mat : capts)+                      Right Nothing -> Nothing+                      Left (_rc, msg) -> E.throw $ RegexException msg
+ src/Skylighting/Styles.hs view
@@ -0,0 +1,278 @@+module Skylighting.Styles (+    parseTheme+  , pygments+  , kate+  , espresso+  , tango+  , haddock+  , monochrome+  , zenburn) where++import Data.Aeson (eitherDecode)+import Data.ByteString.Lazy (ByteString)+import Skylighting.Types++-- | Parse a KDE theme JSON document into a skylighting Style.+parseTheme :: ByteString -> Either String Style+parseTheme = eitherDecode++color :: Int -> Maybe Color+color = toColor++-- | Style based on pygments's default colors.+pygments :: Style+pygments = Style{+    backgroundColor = Nothing+  , defaultColor = Nothing+  , lineNumberColor = color 0xaaaaaa+  , lineNumberBackgroundColor = Nothing+  , tokenStyles =+    [ (KeywordTok, defStyle{ tokenColor = color 0x007020, tokenBold = True })+    , (DataTypeTok, defStyle{ tokenColor = color 0x902000 })+    , (DecValTok, defStyle{ tokenColor = color 0x40a070 })+    , (BaseNTok, defStyle{ tokenColor = color 0x40a070 })+    , (FloatTok, defStyle{ tokenColor = color 0x40a070 })+    , (CharTok, defStyle{ tokenColor = color 0x4070a0 })+    , (StringTok, defStyle{ tokenColor = color 0x4070a0 })+    , (CommentTok, defStyle{ tokenColor = color 0x60a0b0, tokenItalic = True })+    , (OtherTok, defStyle{ tokenColor = color 0x007020 })+    , (AlertTok, defStyle{ tokenColor = color 0xff0000, tokenBold = True })+    , (FunctionTok, defStyle{ tokenColor = color 0x06287e })+    , (ErrorTok, defStyle{ tokenColor = color 0xff0000, tokenBold = True })+    , (WarningTok, defStyle{ tokenColor = color 0x60a0b0, tokenItalic = True, tokenBold = True })+    , (ConstantTok, defStyle{ tokenColor = color 0x880000 })+    , (SpecialCharTok, defStyle{ tokenColor = color 0x4070a0 })+    , (VerbatimStringTok, defStyle{ tokenColor = color 0x4070a0 })+    , (SpecialStringTok, defStyle{ tokenColor = color 0xBB6688 })+    , (ImportTok, defStyle)+    , (VariableTok, defStyle{ tokenColor = color 0x19177C })+    , (ControlFlowTok, defStyle{ tokenColor = color 0x007020, tokenBold = True })+    , (OperatorTok, defStyle{ tokenColor = color 0x666666 })+    , (BuiltInTok, defStyle)+    , (ExtensionTok, defStyle)+    , (PreprocessorTok, defStyle{ tokenColor = color 0xBC7A00 })+    , (AttributeTok, defStyle{ tokenColor = color 0x7D9029 })+    , (DocumentationTok, defStyle{ tokenColor = color 0xBA2121, tokenItalic = True })+    , (AnnotationTok, defStyle{ tokenColor = color 0x60a0b0, tokenItalic = True, tokenBold = True })+    , (CommentVarTok, defStyle{ tokenColor = color 0x60a0b0, tokenItalic = True, tokenBold = True })+    , (InformationTok, defStyle{ tokenColor = color 0x60a0b0, tokenItalic = True, tokenBold = True })+    ]+  }++-- | Style based on kate's default colors.+kate :: Style+kate = Style{+      tokenStyles =+        [ ( KeywordTok, defStyle { tokenColor = Just (RGB 31 28 27), tokenBold = True })+        , ( DataTypeTok, defStyle { tokenColor = Just (RGB 0 87 174) })+        , ( DecValTok, defStyle { tokenColor = Just (RGB 176 128 0) })+        , ( BaseNTok, defStyle { tokenColor = Just (RGB 176 128 0) })+        , ( FloatTok, defStyle { tokenColor = Just (RGB 176 128 0) })+        , ( ConstantTok, defStyle { tokenColor = Just (RGB 170 85 0) })+        , ( CharTok, defStyle { tokenColor = Just (RGB 146 76 157) })+        , ( SpecialCharTok, defStyle { tokenColor = Just (RGB 61 174 233) })+        , ( StringTok, defStyle { tokenColor = Just (RGB 191 3 3) })+        , ( VerbatimStringTok, defStyle { tokenColor = Just (RGB 191 3 3) })+        , ( SpecialStringTok, defStyle { tokenColor = Just (RGB 255 85 0) })+        , ( ImportTok, defStyle { tokenColor = Just (RGB 255 85 0) })+        , ( CommentTok, defStyle { tokenColor = Just (RGB 137 136 135) })+        , ( DocumentationTok, defStyle { tokenColor = Just (RGB 96 120 128) })+        , ( AnnotationTok, defStyle { tokenColor = Just (RGB 202 96 202) })+        , ( CommentVarTok, defStyle { tokenColor = Just (RGB 0 149 255) })+        , ( OtherTok, defStyle { tokenColor = Just (RGB 0 110 40) })+        , ( FunctionTok, defStyle { tokenColor = Just (RGB 100 74 155) })+        , ( VariableTok, defStyle { tokenColor = Just (RGB 0 87 174) })+        , ( ControlFlowTok, defStyle { tokenColor = Just (RGB 31 28 27), tokenBold = True })+        , ( OperatorTok, defStyle { tokenColor = Just (RGB 31 28 27) })+        , ( BuiltInTok, defStyle { tokenColor = Just (RGB 100 74 155), tokenBold = True })+        , ( ExtensionTok, defStyle { tokenColor = Just (RGB 0 149 255), tokenBold = True })+        , ( PreprocessorTok, defStyle { tokenColor = Just (RGB 0 110 40) })+        , ( AttributeTok, defStyle { tokenColor = Just (RGB 0 87 174) })+        , ( RegionMarkerTok, defStyle { tokenColor = Just (RGB 0 87 174) })+        , ( InformationTok, defStyle { tokenColor = Just (RGB 176 128 0) })+        , ( WarningTok, defStyle { tokenColor = Just (RGB 191 3 3) })+        , ( AlertTok, defStyle { tokenColor = Just (RGB 191 3 3), tokenBold = True })+        , ( ErrorTok, defStyle { tokenColor = Just (RGB 191 3 3), tokenUnderline = True })+        , ( NormalTok, defStyle { tokenColor = Just (RGB 31 28 27) })+        ]+    , defaultColor = Just (RGB 31 28 27)+    , backgroundColor = Just (RGB 255 255 255)+    , lineNumberColor = Just (RGB 160 160 160)+    , lineNumberBackgroundColor = Just (RGB 255 255 255)+    }++-- | Style based on pygments's tango colors.+tango :: Style+tango = Style{+    backgroundColor = color 0xf8f8f8+  , defaultColor = Nothing+  , lineNumberColor = color 0xaaaaaa+  , lineNumberBackgroundColor = Nothing+  , tokenStyles =+    [ (KeywordTok, defStyle{ tokenColor = color 0x204a87, tokenBold = True })+    , (DataTypeTok, defStyle{ tokenColor = color 0x204a87 })+    , (DecValTok, defStyle{ tokenColor = color 0x0000cf })+    , (BaseNTok, defStyle{ tokenColor = color 0x0000cf })+    , (FloatTok, defStyle{ tokenColor = color 0x0000cf })+    , (CharTok, defStyle{ tokenColor = color 0x4e9a06 })+    , (StringTok, defStyle{ tokenColor = color 0x4e9a06 })+    , (CommentTok, defStyle{ tokenColor = color 0x8f5902, tokenItalic = True })+    , (OtherTok, defStyle{ tokenColor = color 0x8f5902 })+    , (AlertTok, defStyle{ tokenColor = color 0xef2929 })+    , (FunctionTok, defStyle{ tokenColor = color 0x000000 })+    , (ErrorTok, defStyle{ tokenColor = color 0xa40000, tokenBold = True })+    , (WarningTok, defStyle{ tokenColor = color 0x8f5902, tokenItalic = True,tokenBold = True })+    , (ConstantTok, defStyle{ tokenColor = color 0x000000 })+    , (SpecialCharTok, defStyle{ tokenColor = color 0x000000 })+    , (VerbatimStringTok, defStyle{ tokenColor = color 0x4e9a06 })+    , (SpecialStringTok, defStyle{ tokenColor = color 0x4e9a06 })+    , (ImportTok, defStyle)+    , (VariableTok, defStyle{ tokenColor = color 0x000000 })+    , (ControlFlowTok, defStyle{ tokenColor = color 0x204a87, tokenBold = True })+    , (OperatorTok, defStyle{ tokenColor = color 0xce5c00, tokenBold = True })+    , (PreprocessorTok, defStyle{ tokenColor = color 0x8f5902, tokenItalic = True} )+    , (ExtensionTok, defStyle)+    , (AttributeTok, defStyle{ tokenColor = color 0xc4a000 })+    , (DocumentationTok, defStyle{ tokenColor = color 0x8f5902, tokenItalic = True, tokenBold = True })+    , (AnnotationTok, defStyle{ tokenColor = color 0x8f5902, tokenItalic = True,tokenBold = True })+    , (CommentVarTok, defStyle{ tokenColor = color 0x8f5902, tokenItalic = True,tokenBold = True })+    , (InformationTok, defStyle{ tokenColor = color 0x8f5902, tokenItalic = True,tokenBold = True })+    ]+  }++-- | Style based on ultraviolet's espresso_libre.css (dark background).+espresso :: Style+espresso = Style{+    backgroundColor = color 0x2A211C+  , defaultColor = color 0xBDAE9D+  , lineNumberColor = color 0xBDAE9D+  , lineNumberBackgroundColor = color 0x2A211C+  , tokenStyles =+    [ (KeywordTok, defStyle{ tokenColor = color 0x43A8ED, tokenBold = True })+    , (DataTypeTok, defStyle{ tokenUnderline = True })+    , (DecValTok, defStyle{ tokenColor = color 0x44AA43 })+    , (BaseNTok, defStyle{ tokenColor = color 0x44AA43 })+    , (FloatTok, defStyle{ tokenColor = color 0x44AA43 })+    , (CharTok, defStyle{ tokenColor = color 0x049B0A })+    , (StringTok, defStyle{ tokenColor = color 0x049B0A })+    , (CommentTok, defStyle{ tokenColor = color 0x0066FF, tokenItalic = True })+    , (AlertTok, defStyle{ tokenColor = color 0xffff00 })+    , (FunctionTok, defStyle{ tokenColor = color 0xFF9358, tokenBold = True })+    , (ErrorTok, defStyle{ tokenColor = color 0xffff00, tokenBold = True })+    , (WarningTok, defStyle{ tokenColor = color 0xffff00, tokenBold = True })+    , (ConstantTok, defStyle)+    , (SpecialCharTok, defStyle{ tokenColor = color 0x049B0A })+    , (VerbatimStringTok, defStyle{ tokenColor = color 0x049B0A })+    , (SpecialStringTok, defStyle{ tokenColor = color 0x049B0A })+    , (ImportTok, defStyle)+    , (VariableTok, defStyle)+    , (ControlFlowTok, defStyle{ tokenColor = color 0x43A8ED, tokenBold = True })+    , (OperatorTok, defStyle)+    , (BuiltInTok, defStyle)+    , (ExtensionTok, defStyle)+    , (PreprocessorTok, defStyle{ tokenBold = True })+    , (AttributeTok, defStyle)+    , (DocumentationTok, defStyle{ tokenColor = color 0x0066FF, tokenItalic = True })+    , (AnnotationTok, defStyle{ tokenColor = color 0x0066FF, tokenItalic = True, tokenBold = True })+    , (CommentTok, defStyle{ tokenColor = color 0x0066FF, tokenItalic = True, tokenBold = True })+    , (InformationTok, defStyle{ tokenColor = color 0x0066FF, tokenItalic = True, tokenBold = True })+    ]+  }++-- | Style based on haddock's source highlighting.+haddock :: Style+haddock = Style{+    backgroundColor = Nothing+  , defaultColor = Nothing+  , lineNumberColor = color 0xaaaaaa+  , lineNumberBackgroundColor = Nothing+  , tokenStyles =+    [ (KeywordTok, defStyle{ tokenColor = color 0x0000FF })+    , (CharTok, defStyle{ tokenColor = color 0x008080 })+    , (StringTok, defStyle{ tokenColor = color 0x008080 })+    , (CommentTok, defStyle{ tokenColor = color 0x008000 })+    , (OtherTok, defStyle{ tokenColor = color 0xff4000 })+    , (AlertTok, defStyle{ tokenColor = color 0xff0000 })+    , (ErrorTok, defStyle{ tokenColor = color 0xff0000, tokenBold = True })+    , (WarningTok, defStyle{ tokenColor = color 0x008000, tokenBold = True })+    , (ConstantTok, defStyle)+    , (SpecialCharTok, defStyle{ tokenColor = color 0x008080 })+    , (VerbatimStringTok, defStyle{ tokenColor = color 0x008080 })+    , (SpecialStringTok, defStyle{ tokenColor = color 0x008080 })+    , (ImportTok, defStyle)+    , (VariableTok, defStyle)+    , (ControlFlowTok, defStyle{ tokenColor = color 0x0000FF })+    , (OperatorTok, defStyle)+    , (BuiltInTok, defStyle)+    , (ExtensionTok, defStyle)+    , (PreprocessorTok, defStyle{ tokenColor = color 0xff4000 })+    , (DocumentationTok, defStyle{ tokenColor = color 0x008000 })+    , (AnnotationTok, defStyle{ tokenColor = color 0x008000 })+    , (CommentVarTok, defStyle{ tokenColor = color 0x008000 })+    , (AttributeTok, defStyle)+    , (InformationTok, defStyle{ tokenColor = color 0x008000 })+    ]+  }++-- | Style with no colors.+monochrome :: Style+monochrome = Style{+    backgroundColor = Nothing+  , defaultColor = Nothing+  , lineNumberColor = Nothing+  , lineNumberBackgroundColor = Nothing+  , tokenStyles =+    [ (KeywordTok, defStyle{ tokenBold = True })+    , (DataTypeTok, defStyle{ tokenUnderline = True })+    , (CommentTok, defStyle{ tokenItalic = True })+    , (AlertTok, defStyle{ tokenBold = True })+    , (ErrorTok, defStyle{ tokenBold = True })+    , (WarningTok, defStyle{ tokenItalic = True })+    , (ControlFlowTok, defStyle{ tokenBold = True })+    , (PreprocessorTok, defStyle{ tokenBold = True })+    , (DocumentationTok, defStyle{ tokenItalic = True })+    , (AnnotationTok, defStyle{ tokenItalic = True })+    , (CommentVarTok, defStyle{ tokenItalic = True })+    , (InformationTok, defStyle{ tokenItalic = True })+    ]+  }++-- | Style based on the popular zenburn vim color scheme+zenburn :: Style+zenburn = Style{+    backgroundColor = color 0x303030+  , defaultColor = color 0xcccccc+  , lineNumberColor = Nothing+  , lineNumberBackgroundColor = Nothing+  , tokenStyles =+    [ (KeywordTok, defStyle{ tokenColor = color 0xf0dfaf })+    , (DataTypeTok, defStyle{ tokenColor = color 0xdfdfbf })+    , (DecValTok, defStyle{ tokenColor = color 0xdcdccc })+    , (BaseNTok, defStyle{ tokenColor = color 0xdca3a3 })+    , (FloatTok, defStyle{ tokenColor = color 0xc0bed1 })+    , (CharTok, defStyle{ tokenColor = color 0xdca3a3 })+    , (StringTok, defStyle{ tokenColor = color 0xcc9393 })+    , (CommentTok, defStyle{ tokenColor = color 0x7f9f7f })+    , (OtherTok, defStyle{ tokenColor = color 0xefef8f })+    , (AlertTok, defStyle{ tokenColor = color 0xffcfaf })+    , (FunctionTok, defStyle{ tokenColor = color 0xefef8f })+    , (ErrorTok, defStyle{ tokenColor = color 0xc3bf9f })+    , (WarningTok, defStyle{ tokenColor = color 0x7f9f7f, tokenBold = True })+    , (ConstantTok, defStyle{ tokenColor = color 0xdca3a3, tokenBold = True })+    , (SpecialCharTok, defStyle{ tokenColor = color 0xdca3a3 })+    , (VerbatimStringTok, defStyle{ tokenColor = color 0xcc9393 })+    , (SpecialStringTok, defStyle{ tokenColor = color 0xcc9393 })+    , (ImportTok, defStyle)+    , (VariableTok, defStyle)+    , (ControlFlowTok, defStyle{ tokenColor = color 0xf0dfaf })+    , (OperatorTok, defStyle{ tokenColor = color 0xf0efd0 })+    , (BuiltInTok, defStyle)+    , (ExtensionTok, defStyle)+    , (PreprocessorTok, defStyle{ tokenColor = color 0xffcfaf, tokenBold = True })+    , (AttributeTok, defStyle)+    , (DocumentationTok, defStyle{ tokenColor = color 0x7f9f7f })+    , (AnnotationTok, defStyle{ tokenColor = color 0x7f9f7f, tokenBold = True })+    , (CommentVarTok, defStyle{ tokenColor = color 0x7f9f7f, tokenBold = True })+    , (InformationTok, defStyle{ tokenColor = color 0x7f9f7f, tokenBold = True })+    ]+  }
+ src/Skylighting/Syntax.hs view
@@ -0,0 +1,253 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax (defaultSyntaxMap) where+import qualified Data.Map as Map+import Skylighting.Types+import qualified Skylighting.Syntax.Abc+import qualified Skylighting.Syntax.Actionscript+import qualified Skylighting.Syntax.Ada+import qualified Skylighting.Syntax.Agda+import qualified Skylighting.Syntax.Alert+import qualified Skylighting.Syntax.AlertIndent+import qualified Skylighting.Syntax.Apache+import qualified Skylighting.Syntax.Asn1+import qualified Skylighting.Syntax.Asp+import qualified Skylighting.Syntax.Ats+import qualified Skylighting.Syntax.Awk+import qualified Skylighting.Syntax.Bash+import qualified Skylighting.Syntax.Bibtex+import qualified Skylighting.Syntax.Boo+import qualified Skylighting.Syntax.C+import qualified Skylighting.Syntax.Changelog+import qualified Skylighting.Syntax.Clojure+import qualified Skylighting.Syntax.Cmake+import qualified Skylighting.Syntax.Coffee+import qualified Skylighting.Syntax.Coldfusion+import qualified Skylighting.Syntax.Commonlisp+import qualified Skylighting.Syntax.Cpp+import qualified Skylighting.Syntax.Cs+import qualified Skylighting.Syntax.Css+import qualified Skylighting.Syntax.Curry+import qualified Skylighting.Syntax.D+import qualified Skylighting.Syntax.Diff+import qualified Skylighting.Syntax.Djangotemplate+import qualified Skylighting.Syntax.Dockerfile+import qualified Skylighting.Syntax.Dot+import qualified Skylighting.Syntax.Doxygen+import qualified Skylighting.Syntax.Doxygenlua+import qualified Skylighting.Syntax.Dtd+import qualified Skylighting.Syntax.Eiffel+import qualified Skylighting.Syntax.Elixir+import qualified Skylighting.Syntax.Email+import qualified Skylighting.Syntax.Erlang+import qualified Skylighting.Syntax.Fasm+import qualified Skylighting.Syntax.Fortran+import qualified Skylighting.Syntax.Fsharp+import qualified Skylighting.Syntax.Gcc+import qualified Skylighting.Syntax.Glsl+import qualified Skylighting.Syntax.Gnuassembler+import qualified Skylighting.Syntax.Go+import qualified Skylighting.Syntax.Hamlet+import qualified Skylighting.Syntax.Haskell+import qualified Skylighting.Syntax.Haxe+import qualified Skylighting.Syntax.Html+import qualified Skylighting.Syntax.Idris+import qualified Skylighting.Syntax.Ini+import qualified Skylighting.Syntax.Isocpp+import qualified Skylighting.Syntax.Java+import qualified Skylighting.Syntax.Javadoc+import qualified Skylighting.Syntax.Javascript+import qualified Skylighting.Syntax.Json+import qualified Skylighting.Syntax.Jsp+import qualified Skylighting.Syntax.Julia+import qualified Skylighting.Syntax.Kotlin+import qualified Skylighting.Syntax.Latex+import qualified Skylighting.Syntax.Lex+import qualified Skylighting.Syntax.Lilypond+import qualified Skylighting.Syntax.LiterateCurry+import qualified Skylighting.Syntax.LiterateHaskell+import qualified Skylighting.Syntax.Llvm+import qualified Skylighting.Syntax.Lua+import qualified Skylighting.Syntax.M4+import qualified Skylighting.Syntax.Makefile+import qualified Skylighting.Syntax.Mandoc+import qualified Skylighting.Syntax.Markdown+import qualified Skylighting.Syntax.Mathematica+import qualified Skylighting.Syntax.Matlab+import qualified Skylighting.Syntax.Maxima+import qualified Skylighting.Syntax.Mediawiki+import qualified Skylighting.Syntax.Metafont+import qualified Skylighting.Syntax.Mips+import qualified Skylighting.Syntax.Modelines+import qualified Skylighting.Syntax.Modula2+import qualified Skylighting.Syntax.Modula3+import qualified Skylighting.Syntax.Monobasic+import qualified Skylighting.Syntax.Nasm+import qualified Skylighting.Syntax.Noweb+import qualified Skylighting.Syntax.Objectivec+import qualified Skylighting.Syntax.Objectivecpp+import qualified Skylighting.Syntax.Ocaml+import qualified Skylighting.Syntax.Octave+import qualified Skylighting.Syntax.Opencl+import qualified Skylighting.Syntax.Pascal+import qualified Skylighting.Syntax.Perl+import qualified Skylighting.Syntax.Php+import qualified Skylighting.Syntax.Pike+import qualified Skylighting.Syntax.Postscript+import qualified Skylighting.Syntax.Prolog+import qualified Skylighting.Syntax.Pure+import qualified Skylighting.Syntax.Purebasic+import qualified Skylighting.Syntax.Python+import qualified Skylighting.Syntax.R+import qualified Skylighting.Syntax.Relaxng+import qualified Skylighting.Syntax.Relaxngcompact+import qualified Skylighting.Syntax.Rest+import qualified Skylighting.Syntax.Rhtml+import qualified Skylighting.Syntax.Roff+import qualified Skylighting.Syntax.Ruby+import qualified Skylighting.Syntax.Rust+import qualified Skylighting.Syntax.Scala+import qualified Skylighting.Syntax.Scheme+import qualified Skylighting.Syntax.Sci+import qualified Skylighting.Syntax.Sed+import qualified Skylighting.Syntax.Sgml+import qualified Skylighting.Syntax.SqlMysql+import qualified Skylighting.Syntax.SqlPostgresql+import qualified Skylighting.Syntax.Sql+import qualified Skylighting.Syntax.Tcl+import qualified Skylighting.Syntax.Tcsh+import qualified Skylighting.Syntax.Texinfo+import qualified Skylighting.Syntax.Verilog+import qualified Skylighting.Syntax.Vhdl+import qualified Skylighting.Syntax.Xml+import qualified Skylighting.Syntax.Xorg+import qualified Skylighting.Syntax.Xslt+import qualified Skylighting.Syntax.Xul+import qualified Skylighting.Syntax.Yacc+import qualified Skylighting.Syntax.Yaml+import qualified Skylighting.Syntax.Zsh++defaultSyntaxMap :: SyntaxMap+defaultSyntaxMap = Map.fromList [+     ("ABC", Skylighting.Syntax.Abc.syntax)+  ,  ("ActionScript 2.0", Skylighting.Syntax.Actionscript.syntax)+  ,  ("Ada", Skylighting.Syntax.Ada.syntax)+  ,  ("Agda", Skylighting.Syntax.Agda.syntax)+  ,  ("Alerts", Skylighting.Syntax.Alert.syntax)+  ,  ("Alerts_indent", Skylighting.Syntax.AlertIndent.syntax)+  ,  ("Apache Configuration", Skylighting.Syntax.Apache.syntax)+  ,  ("ASN.1", Skylighting.Syntax.Asn1.syntax)+  ,  ("ASP", Skylighting.Syntax.Asp.syntax)+  ,  ("ATS", Skylighting.Syntax.Ats.syntax)+  ,  ("AWK", Skylighting.Syntax.Awk.syntax)+  ,  ("Bash", Skylighting.Syntax.Bash.syntax)+  ,  ("BibTeX", Skylighting.Syntax.Bibtex.syntax)+  ,  ("Boo", Skylighting.Syntax.Boo.syntax)+  ,  ("C", Skylighting.Syntax.C.syntax)+  ,  ("ChangeLog", Skylighting.Syntax.Changelog.syntax)+  ,  ("Clojure", Skylighting.Syntax.Clojure.syntax)+  ,  ("CMake", Skylighting.Syntax.Cmake.syntax)+  ,  ("CoffeeScript", Skylighting.Syntax.Coffee.syntax)+  ,  ("ColdFusion", Skylighting.Syntax.Coldfusion.syntax)+  ,  ("Common Lisp", Skylighting.Syntax.Commonlisp.syntax)+  ,  ("C++", Skylighting.Syntax.Cpp.syntax)+  ,  ("C#", Skylighting.Syntax.Cs.syntax)+  ,  ("CSS", Skylighting.Syntax.Css.syntax)+  ,  ("Curry", Skylighting.Syntax.Curry.syntax)+  ,  ("D", Skylighting.Syntax.D.syntax)+  ,  ("Diff", Skylighting.Syntax.Diff.syntax)+  ,  ("Django HTML Template", Skylighting.Syntax.Djangotemplate.syntax)+  ,  ("Dockerfile", Skylighting.Syntax.Dockerfile.syntax)+  ,  ("dot", Skylighting.Syntax.Dot.syntax)+  ,  ("Doxygen", Skylighting.Syntax.Doxygen.syntax)+  ,  ("DoxygenLua", Skylighting.Syntax.Doxygenlua.syntax)+  ,  ("DTD", Skylighting.Syntax.Dtd.syntax)+  ,  ("Eiffel", Skylighting.Syntax.Eiffel.syntax)+  ,  ("Elixir", Skylighting.Syntax.Elixir.syntax)+  ,  ("Email", Skylighting.Syntax.Email.syntax)+  ,  ("Erlang", Skylighting.Syntax.Erlang.syntax)+  ,  ("Intel x86 (FASM)", Skylighting.Syntax.Fasm.syntax)+  ,  ("Fortran", Skylighting.Syntax.Fortran.syntax)+  ,  ("FSharp", Skylighting.Syntax.Fsharp.syntax)+  ,  ("GCCExtensions", Skylighting.Syntax.Gcc.syntax)+  ,  ("GLSL", Skylighting.Syntax.Glsl.syntax)+  ,  ("GNU Assembler", Skylighting.Syntax.Gnuassembler.syntax)+  ,  ("Go", Skylighting.Syntax.Go.syntax)+  ,  ("Hamlet", Skylighting.Syntax.Hamlet.syntax)+  ,  ("Haskell", Skylighting.Syntax.Haskell.syntax)+  ,  ("Haxe", Skylighting.Syntax.Haxe.syntax)+  ,  ("HTML", Skylighting.Syntax.Html.syntax)+  ,  ("Idris", Skylighting.Syntax.Idris.syntax)+  ,  ("INI Files", Skylighting.Syntax.Ini.syntax)+  ,  ("ISO C++", Skylighting.Syntax.Isocpp.syntax)+  ,  ("Java", Skylighting.Syntax.Java.syntax)+  ,  ("Javadoc", Skylighting.Syntax.Javadoc.syntax)+  ,  ("JavaScript", Skylighting.Syntax.Javascript.syntax)+  ,  ("JSON", Skylighting.Syntax.Json.syntax)+  ,  ("JSP", Skylighting.Syntax.Jsp.syntax)+  ,  ("Julia", Skylighting.Syntax.Julia.syntax)+  ,  ("Kotlin", Skylighting.Syntax.Kotlin.syntax)+  ,  ("LaTeX", Skylighting.Syntax.Latex.syntax)+  ,  ("Lex/Flex", Skylighting.Syntax.Lex.syntax)+  ,  ("LilyPond", Skylighting.Syntax.Lilypond.syntax)+  ,  ("Literate Curry", Skylighting.Syntax.LiterateCurry.syntax)+  ,  ("Literate Haskell", Skylighting.Syntax.LiterateHaskell.syntax)+  ,  ("LLVM", Skylighting.Syntax.Llvm.syntax)+  ,  ("Lua", Skylighting.Syntax.Lua.syntax)+  ,  ("GNU M4", Skylighting.Syntax.M4.syntax)+  ,  ("Makefile", Skylighting.Syntax.Makefile.syntax)+  ,  ("Troff Mandoc", Skylighting.Syntax.Mandoc.syntax)+  ,  ("Markdown", Skylighting.Syntax.Markdown.syntax)+  ,  ("Mathematica", Skylighting.Syntax.Mathematica.syntax)+  ,  ("Matlab", Skylighting.Syntax.Matlab.syntax)+  ,  ("Maxima", Skylighting.Syntax.Maxima.syntax)+  ,  ("MediaWiki", Skylighting.Syntax.Mediawiki.syntax)+  ,  ("Metapost/Metafont", Skylighting.Syntax.Metafont.syntax)+  ,  ("MIPS Assembler", Skylighting.Syntax.Mips.syntax)+  ,  ("Modelines", Skylighting.Syntax.Modelines.syntax)+  ,  ("Modula-2", Skylighting.Syntax.Modula2.syntax)+  ,  ("Modula-3", Skylighting.Syntax.Modula3.syntax)+  ,  ("MonoBasic", Skylighting.Syntax.Monobasic.syntax)+  ,  ("Intel x86 (NASM)", Skylighting.Syntax.Nasm.syntax)+  ,  ("noweb", Skylighting.Syntax.Noweb.syntax)+  ,  ("Objective-C", Skylighting.Syntax.Objectivec.syntax)+  ,  ("Objective-C++", Skylighting.Syntax.Objectivecpp.syntax)+  ,  ("Objective Caml", Skylighting.Syntax.Ocaml.syntax)+  ,  ("Octave", Skylighting.Syntax.Octave.syntax)+  ,  ("OpenCL", Skylighting.Syntax.Opencl.syntax)+  ,  ("Pascal", Skylighting.Syntax.Pascal.syntax)+  ,  ("Perl", Skylighting.Syntax.Perl.syntax)+  ,  ("PHP/PHP", Skylighting.Syntax.Php.syntax)+  ,  ("Pike", Skylighting.Syntax.Pike.syntax)+  ,  ("PostScript", Skylighting.Syntax.Postscript.syntax)+  ,  ("Prolog", Skylighting.Syntax.Prolog.syntax)+  ,  ("Pure", Skylighting.Syntax.Pure.syntax)+  ,  ("PureBasic", Skylighting.Syntax.Purebasic.syntax)+  ,  ("Python", Skylighting.Syntax.Python.syntax)+  ,  ("R Script", Skylighting.Syntax.R.syntax)+  ,  ("RELAX NG", Skylighting.Syntax.Relaxng.syntax)+  ,  ("RelaxNG-Compact", Skylighting.Syntax.Relaxngcompact.syntax)+  ,  ("reStructuredText", Skylighting.Syntax.Rest.syntax)+  ,  ("Ruby/Rails/RHTML", Skylighting.Syntax.Rhtml.syntax)+  ,  ("Roff", Skylighting.Syntax.Roff.syntax)+  ,  ("Ruby", Skylighting.Syntax.Ruby.syntax)+  ,  ("Rust", Skylighting.Syntax.Rust.syntax)+  ,  ("Scala", Skylighting.Syntax.Scala.syntax)+  ,  ("Scheme", Skylighting.Syntax.Scheme.syntax)+  ,  ("scilab", Skylighting.Syntax.Sci.syntax)+  ,  ("sed", Skylighting.Syntax.Sed.syntax)+  ,  ("SGML", Skylighting.Syntax.Sgml.syntax)+  ,  ("SQL (MySQL)", Skylighting.Syntax.SqlMysql.syntax)+  ,  ("SQL (PostgreSQL)", Skylighting.Syntax.SqlPostgresql.syntax)+  ,  ("SQL", Skylighting.Syntax.Sql.syntax)+  ,  ("Tcl/Tk", Skylighting.Syntax.Tcl.syntax)+  ,  ("Tcsh", Skylighting.Syntax.Tcsh.syntax)+  ,  ("Texinfo", Skylighting.Syntax.Texinfo.syntax)+  ,  ("Verilog", Skylighting.Syntax.Verilog.syntax)+  ,  ("VHDL", Skylighting.Syntax.Vhdl.syntax)+  ,  ("XML", Skylighting.Syntax.Xml.syntax)+  ,  ("x.org Configuration", Skylighting.Syntax.Xorg.syntax)+  ,  ("xslt", Skylighting.Syntax.Xslt.syntax)+  ,  ("XUL", Skylighting.Syntax.Xul.syntax)+  ,  ("Yacc/Bison", Skylighting.Syntax.Yacc.syntax)+  ,  ("YAML", Skylighting.Syntax.Yaml.syntax)+  ,  ("Zsh", Skylighting.Syntax.Zsh.syntax) ]
+ src/Skylighting/Syntax/Abc.hs view
@@ -0,0 +1,455 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Abc (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex++syntax :: Syntax+syntax = Syntax+  { sName = "ABC"+  , sFilename = "abc.xml"+  , sShortname = "Abc"+  , sContexts =+      fromList+        [ ( "Bar"+          , Context+              { cName = "Bar"+              , cSyntax = "ABC"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Ga-gZz]"+                              , reCompiled = Just (compileRegex True "[A-Ga-gZz]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar ' '+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = RangeDetect '!' '!'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "()"+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ":*\\|*[1-9]|/*\\|"+                              , reCompiled = Just (compileRegex True ":*\\|*[1-9]|/*\\|")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "ABC"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Header"+          , Context+              { cName = "Header"+              , cSyntax = "ABC"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "K:.+"+                              , reCompiled = Just (compileRegex True "K:.+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = FloatTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Header2"+          , Context+              { cName = "Header2"+              , cSyntax = "ABC"+              , cRules = []+              , cAttribute = FloatTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Lyrics"+          , Context+              { cName = "Lyrics"+              , cSyntax = "ABC"+              , cRules = []+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "ABC"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\([23456789]:?[23456789]?:?[23456789]?"+                              , reCompiled =+                                  Just (compileRegex True "\\([23456789]:?[23456789]?:?[23456789]?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = RangeDetect '"' '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = RangeDetect '!' '!'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[[ABCGHILMNOQRSTUVZ]:"+                              , reCompiled = Just (compileRegex True "\\[[ABCGHILMNOQRSTUVZ]:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ABC" , "Header" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[ABCGHILMNOPQRSTUVZ]:"+                              , reCompiled = Just (compileRegex True "[ABCGHILMNOPQRSTUVZ]:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ABC" , "Header2" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars 'X' ':'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "ABC" , "Header" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "|:["+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ABC" , "Bar" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "()"+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "{}"+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars 'W' ':'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ABC" , "Lyrics" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars 'w' ':'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ABC" , "Lyrics" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '%' '%'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ABC" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ABC" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[_|\\^]?[_|=|\\^][A-Ga-g]"+                              , reCompiled = Just (compileRegex True "[_|\\^]?[_|=|\\^][A-Ga-g]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Part"+          , Context+              { cName = "Part"+              , cSyntax = "ABC"+              , cRules = []+              , cAttribute = FloatTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Preprocessor"+          , Context+              { cName = "Preprocessor"+              , cSyntax = "ABC"+              , cRules = []+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Andrea Primiani (primiani@dag.it)"+  , sVersion = "3"+  , sLicense = "LGPL"+  , sExtensions = [ "*.abc" , "*.ABC" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Actionscript.hs view
@@ -0,0 +1,957 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Actionscript (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "ActionScript 2.0"+  , sFilename = "actionscript.xml"+  , sShortname = "Actionscript"+  , sContexts =+      fromList+        [ ( "Commentar 1"+          , Context+              { cName = "Commentar 1"+              , cSyntax = "ActionScript 2.0"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Commentar 2"+          , Context+              { cName = "Commentar 2"+              , cSyntax = "ActionScript 2.0"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Imports"+          , Context+              { cName = "Imports"+              , cSyntax = "ActionScript 2.0"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*.*$"+                              , reCompiled = Just (compileRegex True "\\s*.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ImportTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Member"+          , Context+              { cName = "Member"+              , cSyntax = "ActionScript 2.0"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[_a-zA-Z]\\w*(?=[\\s]*)"+                              , reCompiled =+                                  Just (compileRegex True "\\b[_a-zA-Z]\\w*(?=[\\s]*)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "ActionScript 2.0"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Javadoc" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "_accProps"+                               , "_focusrect"+                               , "_global"+                               , "_highquality"+                               , "_level"+                               , "_parent"+                               , "_quality"+                               , "_root"+                               , "_soundbuftime"+                               , "maxscroll"+                               , "scroll"+                               , "this"+                               ])+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "asfunction"+                               , "call"+                               , "chr"+                               , "clearInterval"+                               , "duplicateMovieClip"+                               , "escape"+                               , "eval"+                               , "fscommand"+                               , "getProperty"+                               , "getTimer"+                               , "getURL"+                               , "getVersion"+                               , "gotoAndPlay"+                               , "gotoAndStop"+                               , "ifFrameLoaded"+                               , "int"+                               , "isFinite"+                               , "isNaN"+                               , "length"+                               , "loadMovie"+                               , "loadMovieNum"+                               , "loadVariables"+                               , "loadVariablesNum"+                               , "mbchr"+                               , "mblength"+                               , "mbord"+                               , "mbsubstring"+                               , "nextFrame"+                               , "nextScene"+                               , "on"+                               , "onClipEvent"+                               , "ord"+                               , "parseFloat"+                               , "parseInt"+                               , "play"+                               , "prevFrame"+                               , "prevScene"+                               , "print"+                               , "printAsBitmap"+                               , "printAsBitmapNum"+                               , "printNum"+                               , "random"+                               , "removeMovieClip"+                               , "setInterval"+                               , "setProperty"+                               , "showRedrawRegions"+                               , "startDrag"+                               , "stop"+                               , "stopAllSounds"+                               , "stopDrag"+                               , "substring"+                               , "targetPath"+                               , "tellTarget"+                               , "toggleHighQuality"+                               , "trace"+                               , "typeof"+                               , "unescape"+                               , "unloadMovie"+                               , "unloadMovieNum"+                               , "updateAfterEvent"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Accessibility"+                               , "Accordion"+                               , "Alert"+                               , "Binding"+                               , "Button"+                               , "Camera"+                               , "CellRenderer"+                               , "CheckBox"+                               , "Collection"+                               , "Color"+                               , "ComboBox"+                               , "ComponentMixins"+                               , "ContextMenu"+                               , "ContextMenuItem"+                               , "CustomActions"+                               , "CustomFormatter"+                               , "CustomValidator"+                               , "DataGrid"+                               , "DataHolder"+                               , "DataProvider"+                               , "DataSet"+                               , "DataType"+                               , "Date"+                               , "DateChooser"+                               , "DateField"+                               , "Delta"+                               , "DeltaItem"+                               , "DeltaPacket"+                               , "DepthManager"+                               , "EndPoint"+                               , "Error"+                               , "FaultEvent"+                               , "FocusManager"+                               , "Form"+                               , "Function"+                               , "Iterator"+                               , "Key"+                               , "Label"+                               , "List"+                               , "LoadVars"+                               , "Loader"+                               , "LocalConnection"+                               , "Log"+                               , "Math"+                               , "Media"+                               , "Menu"+                               , "MenuBar"+                               , "Microphone"+                               , "Mouse"+                               , "MovieClip"+                               , "MovieClipLoader"+                               , "NetConnection"+                               , "NetStream"+                               , "Number"+                               , "NumericStepper"+                               , "PendingCall"+                               , "PopUpManager"+                               , "PrintJob"+                               , "ProgressBar"+                               , "RDBMSResolver"+                               , "RadioButton"+                               , "RelayResponder"+                               , "SOAPCall"+                               , "Screen"+                               , "ScrollPane"+                               , "Selection"+                               , "SharedObject"+                               , "Slide"+                               , "Sound"+                               , "Stage"+                               , "StyleManager"+                               , "System"+                               , "TextArea"+                               , "TextField"+                               , "TextFormat"+                               , "TextInput"+                               , "TextSnapshot"+                               , "TransferObject"+                               , "Tree"+                               , "TreeDataProvider"+                               , "TypedValue"+                               , "UIComponent"+                               , "UIEventDispatcher"+                               , "UIObject"+                               , "Video"+                               , "WebService"+                               , "WebServiceConnector"+                               , "Window"+                               , "XML"+                               , "XMLConnector"+                               , "XUpdateResolver"+                               ])+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "add"+                               , "and"+                               , "break"+                               , "case"+                               , "catch"+                               , "class"+                               , "continue"+                               , "default"+                               , "delete"+                               , "do"+                               , "dynamic"+                               , "else"+                               , "eq"+                               , "extends"+                               , "finally"+                               , "for"+                               , "function"+                               , "ge"+                               , "get"+                               , "gt"+                               , "if"+                               , "implements"+                               , "import"+                               , "in"+                               , "instanceof"+                               , "interface"+                               , "intrinsic"+                               , "le"+                               , "lt"+                               , "ne"+                               , "new"+                               , "not"+                               , "or"+                               , "private"+                               , "public"+                               , "return"+                               , "set"+                               , "static"+                               , "switch"+                               , "throw"+                               , "try"+                               , "var"+                               , "void"+                               , "while"+                               , "with"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "-Infinity"+                               , "Infinity"+                               , "NaN"+                               , "false"+                               , "newline"+                               , "null"+                               , "true"+                               , "undefined"+                               ])+                      , rAttribute = ConstantTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Array" , "Boolean" , "Number" , "Object" , "String" , "Void" ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren =+                          [ Rule+                              { rMatcher = AnyChar "fF"+                              , rAttribute = FloatTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = True+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren =+                          [ Rule+                              { rMatcher = StringDetect "ULL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LUL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LLU"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "UL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LU"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "U"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "L"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "//\\s*BEGIN.*$"+                              , reCompiled = Just (compileRegex True "//\\s*BEGIN.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "//\\s*END.*$"+                              , reCompiled = Just (compileRegex True "//\\s*END.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ActionScript 2.0" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ActionScript 2.0" , "Commentar 1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ActionScript 2.0" , "Commentar 2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.{3,3}\\s+"+                              , reCompiled = Just (compileRegex True "\\.{3,3}\\s+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(import\\s+static)\\b"+                              , reCompiled = Just (compileRegex True "\\b(import\\s+static)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "ActionScript 2.0" , "StaticImports" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(package|import)\\b"+                              , reCompiled = Just (compileRegex True "\\b(package|import)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ActionScript 2.0" , "Imports" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b[_\\w][_\\w\\d]*(?=[\\s]*(/\\*\\s*\\d+\\s*\\*/\\s*)?[(])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\b[_\\w][_\\w\\d]*(?=[\\s]*(/\\*\\s*\\d+\\s*\\*/\\s*)?[(])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[.]{1,1}"+                              , reCompiled = Just (compileRegex True "[.]{1,1}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ActionScript 2.0" , "Member" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar ":!%&()+,-/.*<=>?[]|~^;"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "StaticImports"+          , Context+              { cName = "StaticImports"+              , cSyntax = "ActionScript 2.0"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*.*$"+                              , reCompiled = Just (compileRegex True "\\s*.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ImportTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "ActionScript 2.0"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Aaron Miller (armantic101@gmail.com)"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions = [ "*.as" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Ada.hs view
@@ -0,0 +1,604 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Ada (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Ada"+  , sFilename = "ada.xml"+  , sShortname = "Ada"+  , sContexts =+      fromList+        [ ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "Ada"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Default"+          , Context+              { cName = "Default"+              , cSyntax = "Ada"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\brecord\\b"+                              , reCompiled = Just (compileRegex False "\\brecord\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bend\\s+record\\b"+                              , reCompiled = Just (compileRegex False "\\bend\\s+record\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bcase\\b"+                              , reCompiled = Just (compileRegex False "\\bcase\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bend\\s+case\\b"+                              , reCompiled = Just (compileRegex False "\\bend\\s+case\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bif\\b"+                              , reCompiled = Just (compileRegex False "\\bif\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bend\\s+if\\b"+                              , reCompiled = Just (compileRegex False "\\bend\\s+if\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bloop\\b"+                              , reCompiled = Just (compileRegex False "\\bloop\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bend\\s+loop\\b"+                              , reCompiled = Just (compileRegex False "\\bend\\s+loop\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bselect\\b"+                              , reCompiled = Just (compileRegex False "\\bselect\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bend\\s+select\\b"+                              , reCompiled = Just (compileRegex False "\\bend\\s+select\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bbegin\\b"+                              , reCompiled = Just (compileRegex False "\\bbegin\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bend\\b"+                              , reCompiled = Just (compileRegex False "\\bend\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "--  BEGIN"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ada" , "Region Marker" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "--  END"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ada" , "Region Marker" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "abort"+                               , "abs"+                               , "abstract"+                               , "accept"+                               , "access"+                               , "aliased"+                               , "all"+                               , "and"+                               , "array"+                               , "at"+                               , "begin"+                               , "body"+                               , "constant"+                               , "declare"+                               , "delay"+                               , "delta"+                               , "digits"+                               , "do"+                               , "else"+                               , "elsif"+                               , "end"+                               , "entry"+                               , "exception"+                               , "exit"+                               , "for"+                               , "function"+                               , "generic"+                               , "goto"+                               , "in"+                               , "interface"+                               , "is"+                               , "limited"+                               , "mod"+                               , "new"+                               , "not"+                               , "null"+                               , "of"+                               , "or"+                               , "others"+                               , "out"+                               , "overriding"+                               , "package"+                               , "pragma"+                               , "private"+                               , "procedure"+                               , "protected"+                               , "raise"+                               , "range"+                               , "record"+                               , "rem"+                               , "renames"+                               , "requeue"+                               , "return"+                               , "reverse"+                               , "separate"+                               , "subtype"+                               , "tagged"+                               , "task"+                               , "terminate"+                               , "then"+                               , "type"+                               , "until"+                               , "use"+                               , "when"+                               , "while"+                               , "with"+                               , "xor"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "all_calls_remote"+                               , "assert"+                               , "assertion_policy"+                               , "asynchronous"+                               , "atomic"+                               , "atomic_components"+                               , "attach_handler"+                               , "controlled"+                               , "convention"+                               , "detect_blocking"+                               , "discard_names"+                               , "elaborate"+                               , "elaborate_all"+                               , "elaborate_body"+                               , "export"+                               , "import"+                               , "inline"+                               , "inspection_point"+                               , "interrupt_handler"+                               , "interrupt_priority"+                               , "linker_options"+                               , "list"+                               , "locking_policy"+                               , "no_return"+                               , "normalize_scalars"+                               , "optimize"+                               , "pack"+                               , "page"+                               , "partition_elaboration_policy"+                               , "preelaborable_initialization"+                               , "preelaborate"+                               , "priority"+                               , "priority_specific_dispatching"+                               , "profile"+                               , "pure"+                               , "queuing_policy"+                               , "relative_deadline"+                               , "remote_call_interface"+                               , "remote_types"+                               , "restrictions"+                               , "reviewable"+                               , "shared_passive"+                               , "storage_size"+                               , "suppress"+                               , "task_dispatching_policy"+                               , "unchecked_union"+                               , "unsuppress"+                               , "volatile"+                               , "volatile_components"+                               ])+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "boolean"+                               , "character"+                               , "float"+                               , "integer"+                               , "long_float"+                               , "long_integer"+                               , "long_long_float"+                               , "long_long_integer"+                               , "short_float"+                               , "short_integer"+                               , "string"+                               , "wide_character"+                               , "wide_string"+                               , "wide_wide_character"+                               , "wide_wide_string"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'.'"+                              , reCompiled = Just (compileRegex True "'.'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ada" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '-' '-'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ada" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar ":!%&()+,-/.*<=>|"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Region Marker"+          , Context+              { cName = "Region Marker"+              , cSyntax = "Ada"+              , cRules = []+              , cAttribute = RegionMarkerTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Ada"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = ""+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.adb" , "*.ads" , "*.ada" , "*.a" ]+  , sStartingContext = "Default"+  }
+ src/Skylighting/Syntax/Agda.hs view
@@ -0,0 +1,442 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Agda (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Agda"+  , sFilename = "agda.xml"+  , sShortname = "Agda"+  , sContexts =+      fromList+        [ ( "char"+          , Context+              { cName = "char"+              , cSyntax = "Agda"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "code"+          , Context+              { cName = "code"+              , cSyntax = "Agda"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{-#.*#-\\}"+                              , reCompiled = Just (compileRegex True "\\{-#.*#-\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n \"().;@_{}"+                              }+                            (makeWordSet+                               True+                               [ "abstract"+                               , "codata"+                               , "coinductive"+                               , "constructor"+                               , "data"+                               , "field"+                               , "forall"+                               , "hiding"+                               , "import"+                               , "in"+                               , "inductive"+                               , "infix"+                               , "infixl"+                               , "infixr"+                               , "let"+                               , "module"+                               , "mutual"+                               , "open"+                               , "pattern"+                               , "postulate"+                               , "primitive"+                               , "private"+                               , "public"+                               , "quote"+                               , "quoteGoal"+                               , "quoteTerm"+                               , "record"+                               , "renaming"+                               , "rewrite"+                               , "syntax"+                               , "to"+                               , "unquote"+                               , "using"+                               , "where"+                               , "with"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(Prop|Set[\226\130\128-\226\130\137]+|Set[0-9]*)(?=([_;.\"(){}@]|\\s|$))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(Prop|Set[\226\130\128-\226\130\137]+|Set[0-9]*)(?=([_;.\"(){}@]|\\s|$))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(->|\226\134\146|\226\136\128|\206\187|:|=|\\|)(?=([_;.\"(){}@]|\\s|$))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(->|\226\134\146|\226\136\128|\206\187|:|=|\\|)(?=([_;.\"(){}@]|\\s|$))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\d+\\.\\d+(?=([_;.\"(){}@]|\\s|$))"+                              , reCompiled =+                                  Just (compileRegex True "\\d+\\.\\d+(?=([_;.\"(){}@]|\\s|$))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[0-9]+(?=([_;.\"(){}@]|\\s|$))"+                              , reCompiled =+                                  Just (compileRegex True "[0-9]+(?=([_;.\"(){}@]|\\s|$))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Agda" , "char" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Agda" , "string" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '-' '-'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Agda" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '{' '-'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Agda" , "comments" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '{' '!'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Agda" , "hole" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "_;.\"(){}@\\\\"+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^_;.\"(){}@\\s]+"+                              , reCompiled = Just (compileRegex True "[^_;.\"(){}@\\s]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "comment"+          , Context+              { cName = "comment"+              , cSyntax = "Agda"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "comments"+          , Context+              { cName = "comments"+              , cSyntax = "Agda"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '{' '-'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Agda" , "comments" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '-' '}'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "hole"+          , Context+              { cName = "hole"+              , cSyntax = "Agda"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '!' '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "string"+          , Context+              { cName = "string"+              , cSyntax = "Agda"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Matthias C. M. Troffaes"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions = [ "*.agda" ]+  , sStartingContext = "code"+  }
+ src/Skylighting/Syntax/Alert.hs view
@@ -0,0 +1,154 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Alert (syntax) where++import Skylighting.Types+import Data.Map+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Alerts"+  , sFilename = "alert.xml"+  , sShortname = "Alert"+  , sContexts =+      fromList+        [ ( "Normal Text"+          , Context+              { cName = "Normal Text"+              , cSyntax = "Alerts"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "{{{"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "}}}"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "BEGIN"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "END"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True [ "ALERT" , "ATTENTION" , "DANGER" , "HACK" , "SECURITY" ])+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "BUG"+                               , "CAUTION"+                               , "DEPRECATED"+                               , "FIXME"+                               , "NOLINT"+                               , "TASK"+                               , "TBD"+                               , "TODO"+                               , "WARNING"+                               ])+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True [ "###" , "NOTE" , "NOTICE" , "TEST" , "TESTING" ])+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Dominik Haumann (dhdev@gmx.de)"+  , sVersion = "3"+  , sLicense = "LGPLv2+"+  , sExtensions = []+  , sStartingContext = "Normal Text"+  }
+ src/Skylighting/Syntax/AlertIndent.hs view
@@ -0,0 +1,47 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.AlertIndent (syntax) where++import Skylighting.Types+import Data.Map++syntax :: Syntax+syntax = Syntax+  { sName = "Alerts_indent"+  , sFilename = "alert_indent.xml"+  , sShortname = "AlertIndent"+  , sContexts =+      fromList+        [ ( "Normal Text"+          , Context+              { cName = "Normal Text"+              , cSyntax = "Alerts_indent"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Dominik Haumann (dhdev@gmx.de)"+  , sVersion = "3"+  , sLicense = "LGPLv2+"+  , sExtensions = []+  , sStartingContext = "Normal Text"+  }
+ src/Skylighting/Syntax/Apache.hs view
@@ -0,0 +1,1019 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Apache (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Apache Configuration"+  , sFilename = "apache.xml"+  , sShortname = "Apache"+  , sContexts =+      fromList+        [ ( "Alert"+          , Context+              { cName = "Alert"+              , cSyntax = "Apache Configuration"+              , cRules = []+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Alternative Directives"+          , Context+              { cName = "Alternative Directives"+              , cSyntax = "Apache Configuration"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "alert"+                               , "All"+                               , "Allow,Deny"+                               , "always"+                               , "Any"+                               , "Ascending"+                               , "auth"+                               , "auth-int"+                               , "AuthConfig"+                               , "Basic"+                               , "Block"+                               , "CompatEnvVars"+                               , "Connection"+                               , "Cookie"+                               , "Cookie2"+                               , "crit"+                               , "Date"+                               , "DB"+                               , "dbm:"+                               , "dc:"+                               , "debug"+                               , "Default"+                               , "Deny,Allow"+                               , "Descending"+                               , "Description"+                               , "Digest"+                               , "DNS"+                               , "Double"+                               , "EMail"+                               , "emerg"+                               , "error"+                               , "ExecCGI"+                               , "ExportCertData"+                               , "FakeBasicAuth"+                               , "Fallback"+                               , "fcntl"+                               , "fcntl:"+                               , "file:"+                               , "FileInfo"+                               , "Filters"+                               , "finding"+                               , "flock"+                               , "flock:"+                               , "FollowSymLinks"+                               , "formatted"+                               , "Full"+                               , "GDBM"+                               , "GDSF"+                               , "Handlers"+                               , "Ignore"+                               , "Includes"+                               , "IncludesNOEXEC"+                               , "Indexes"+                               , "info"+                               , "inherit"+                               , "INode"+                               , "IsError"+                               , "Keep-Alive"+                               , "Limit"+                               , "LRU"+                               , "Major"+                               , "map"+                               , "MD5"+                               , "MD5-sess"+                               , "Min"+                               , "Minimal"+                               , "Minor"+                               , "MTime"+                               , "MultiViews"+                               , "Mutual-failure"+                               , "Name"+                               , "NDBM"+                               , "NegotiatedOnly"+                               , "Netscape"+                               , "never"+                               , "no"+                               , "nocontent"+                               , "None"+                               , "nonenotnull"+                               , "notice"+                               , "Off"+                               , "On"+                               , "optional"+                               , "optional_no_ca"+                               , "Options"+                               , "OptRenegotiate"+                               , "OS"+                               , "posixsem"+                               , "Prefer"+                               , "Prod"+                               , "ProductOnly"+                               , "Proxy-Authenticate"+                               , "Proxy-Authorization"+                               , "pthread"+                               , "referer"+                               , "Registry"+                               , "Registry-Strict"+                               , "require"+                               , "RFC2109"+                               , "RFC2965"+                               , "Script"+                               , "SDBM"+                               , "searching"+                               , "sem"+                               , "semiformatted"+                               , "shm:"+                               , "Size"+                               , "SSL"+                               , "SSLv2"+                               , "SSLv3"+                               , "StartBody"+                               , "STARTTLS"+                               , "StdEnvVars"+                               , "StrictRequire"+                               , "SymLinksIfOwnerMatch"+                               , "sysvsem"+                               , "TE"+                               , "TLS"+                               , "TLSv1"+                               , "Trailers"+                               , "Transfer-Encoding"+                               , "unformatted"+                               , "Upgrade"+                               , "warn"+                               , "yes"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '-'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '+'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Apache Configuration" , "Comment Alert" )+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "Apache Configuration"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment Alert"+          , Context+              { cName = "Comment Alert"+              , cSyntax = "Apache Configuration"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Apache Configuration" , "Alert" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Container Close"+          , Context+              { cName = "Container Close"+              , cSyntax = "Apache Configuration"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Apache Configuration" , "Alert" ) ]+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Container Open"+          , Context+              { cName = "Container Open"+              , cSyntax = "Apache Configuration"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Apache Configuration" , "Alert" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^#>]*"+                              , reCompiled = Just (compileRegex True "[^#>]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Apache Configuration" , "Comment Alert" )+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Integer Directives"+          , Context+              { cName = "Integer Directives"+              , cSyntax = "Apache Configuration"+              , cRules =+                  [ Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Apache Configuration" , "Integer Directives" ) ]+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Apache Configuration" , "Integer Directives" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Apache Configuration" , "Comment Alert" )+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String Directives"+          , Context+              { cName = "String Directives"+              , cSyntax = "Apache Configuration"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^#]*"+                              , reCompiled = Just (compileRegex True "[^#]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Apache Configuration" , "Comment Alert" )+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ExtensionTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "apache"+          , Context+              { cName = "apache"+              , cSyntax = "Apache Configuration"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "AcceptFilter"+                               , "AccessFileName"+                               , "Action"+                               , "AddAlt"+                               , "AddAltByEncoding"+                               , "AddAltByType"+                               , "AddCharset"+                               , "AddDefaultCharset"+                               , "AddDescription"+                               , "AddEncoding"+                               , "AddHandler"+                               , "AddIcon"+                               , "AddIconByEncoding"+                               , "AddIconByType"+                               , "AddInputFilter"+                               , "AddLanguage"+                               , "AddModuleInfo"+                               , "AddOutputFilter"+                               , "AddOutputFilterByType"+                               , "AddType"+                               , "Alias"+                               , "AliasMatch"+                               , "Allow"+                               , "Anonymous"+                               , "AuthBasicProvider"+                               , "AuthDBMGroupFile"+                               , "AuthDBMUserFile"+                               , "AuthDigestDomain"+                               , "AuthDigestFile"+                               , "AuthDigestGroupFile"+                               , "AuthDigestNonceFormat"+                               , "AuthDigestProvider"+                               , "AuthGroupFile"+                               , "AuthLDAPBindDN"+                               , "AuthLDAPBindPassword"+                               , "AuthLDAPCharsetConfig"+                               , "AuthLDAPGroupAttribute"+                               , "AuthLDAPUrl"+                               , "AuthName"+                               , "AuthUserFile"+                               , "BrowserMatch"+                               , "BrowserMatchNoCase"+                               , "BS2000Account"+                               , "CacheDisable"+                               , "CacheEnable"+                               , "CacheFile"+                               , "CacheGcClean"+                               , "CacheGcUnused"+                               , "CacheRoot"+                               , "CGIMapExtension"+                               , "CharsetDefault"+                               , "CharsetOptions"+                               , "CharsetSourceEnc"+                               , "CookieDomain"+                               , "CookieLog"+                               , "CookieName"+                               , "CoreDumpDirectory"+                               , "CustomLog"+                               , "Dav"+                               , "DavGenericLockDB"+                               , "DavLockDB"+                               , "DBDParams"+                               , "DBDPrepareSQL"+                               , "DBDriver"+                               , "DefaultIcon"+                               , "DefaultLanguage"+                               , "DefaultType"+                               , "DeflateFilterNote"+                               , "Deny"+                               , "DirectoryIndex"+                               , "DocumentRoot"+                               , "ErrorDocument"+                               , "ErrorLog"+                               , "Example"+                               , "ExpiresByType"+                               , "ExpiresDefault"+                               , "ExtFilterDefine"+                               , "ExtFilterOptions"+                               , "FilterChain"+                               , "FilterDeclare"+                               , "FilterProtocol"+                               , "FilterProvider"+                               , "FilterTrace"+                               , "ForceType"+                               , "ForensicLog"+                               , "Group"+                               , "Header"+                               , "HeaderName"+                               , "ImapBase"+                               , "Include"+                               , "IndexIgnore"+                               , "IndexOptions"+                               , "IndexStyleSheet"+                               , "ISAPICacheFile"+                               , "LanguagePriority"+                               , "LDAPSharedCacheFile"+                               , "LDAPTrustedCA"+                               , "LDAPTrustedCAType"+                               , "LDAPTrustedClientCert"+                               , "LDAPTrustedGlobalCert"+                               , "Listen"+                               , "LoadFile"+                               , "LoadModule"+                               , "LockFile"+                               , "LogFormat"+                               , "MetaDir"+                               , "MetaSuffix"+                               , "MimeMagicFile"+                               , "MMapFile"+                               , "NameVirtualHost"+                               , "NoProxy"+                               , "NWSSLTrustedCerts"+                               , "NWSSLUpgradeable"+                               , "PassEnv"+                               , "PidFile"+                               , "ProxyBlock"+                               , "ProxyDomain"+                               , "ProxyPass"+                               , "ProxyPassReverse"+                               , "ProxyPassReverseCookieDomain"+                               , "ProxyPassReverseCookiePath"+                               , "ProxyRemote"+                               , "ProxyRemoteMatch"+                               , "ReadmeName"+                               , "Redirect"+                               , "RedirectMatch"+                               , "RedirectPermanent"+                               , "RedirectTemp"+                               , "RemoveCharset"+                               , "RemoveEncoding"+                               , "RemoveHandler"+                               , "RemoveInputFilter"+                               , "RemoveLanguage"+                               , "RemoveOutputFilter"+                               , "RemoveType"+                               , "RequestHeader"+                               , "Require"+                               , "RewriteBase"+                               , "RewriteCond"+                               , "RewriteLock"+                               , "RewriteLog"+                               , "RewriteMap"+                               , "RewriteRule"+                               , "ScoreBoardFile"+                               , "Script"+                               , "ScriptAlias"+                               , "ScriptAliasMatch"+                               , "ScriptLog"+                               , "ScriptSock"+                               , "SecureListen"+                               , "ServerAdmin"+                               , "ServerAlias"+                               , "ServerName"+                               , "ServerPath"+                               , "ServerRoot"+                               , "SetEnv"+                               , "SetEnvIf"+                               , "SetEnvIfNoCase"+                               , "SetHandler"+                               , "SetInputFilter"+                               , "SetOutputFilter"+                               , "SSIEndTag"+                               , "SSIErrorMsg"+                               , "SSIStartTag"+                               , "SSITimeFormat"+                               , "SSIUndefinedEcho"+                               , "SSLCACertificateFile"+                               , "SSLCACertificatePath"+                               , "SSLCADNRequestFile"+                               , "SSLCADNRequestPath"+                               , "SSLCARevocationFile"+                               , "SSLCARevocationPath"+                               , "SSLCertificateChainFile"+                               , "SSLCertificateFile"+                               , "SSLCertificateKeyFile"+                               , "SSLCipherSuite"+                               , "SSLCryptoDevice"+                               , "SSLHonorCiperOrder"+                               , "SSLPassPhraseDialog"+                               , "SSLProxyCACertificateFile"+                               , "SSLProxyCACertificatePath"+                               , "SSLProxyCARevocationFile"+                               , "SSLProxyCARevocationPath"+                               , "SSLProxyCipherSuite"+                               , "SSLProxyMachineCertificateFile"+                               , "SSLProxyMachineCertificatePath"+                               , "SSLProxyProtocol"+                               , "SSLRandomSeed"+                               , "SSLRequire"+                               , "SSLRequireSSL"+                               , "SSLUserName"+                               , "SuexecUserGroup"+                               , "TransferLog"+                               , "TypesConfig"+                               , "UnsetEnv"+                               , "User"+                               , "UserDir"+                               , "VirtualDocumentRoot"+                               , "VirtualDocumentRootIP"+                               , "VirtualScriptAlias"+                               , "VirtualScriptAliasIP"+                               , "Win32DisableAcceptEx"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Apache Configuration" , "String Directives" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "AllowCONNECT"+                               , "AssignUserID"+                               , "AuthDigestNonceLifetime"+                               , "AuthDigestShmemSize"+                               , "CacheDefaultExpire"+                               , "CacheDirLength"+                               , "CacheDirLevels"+                               , "CacheForceCompletion"+                               , "CacheGcDaily"+                               , "CacheGcInterval"+                               , "CacheGcMemUsage"+                               , "CacheLastModifiedFactor"+                               , "CacheMaxExpire"+                               , "CacheMaxFileSize"+                               , "CacheMinFileSize"+                               , "CacheSize"+                               , "CacheTimeMargin"+                               , "ChildPerUserID"+                               , "CookieExpires"+                               , "DavMinTimeout"+                               , "DBDExptime"+                               , "DBDKeep"+                               , "DBDMax"+                               , "DBDMin"+                               , "DBDPersist"+                               , "DeflateBufferSize"+                               , "DeflateCompressionLevel"+                               , "DeflateMemLevel"+                               , "DeflateWindowSize"+                               , "IdentityCheckTimeout"+                               , "ISAPIReadAheadBuffer"+                               , "KeepAliveTimeout"+                               , "LDAPCacheEntries"+                               , "LDAPCacheTTL"+                               , "LDAPConnectionTimeout"+                               , "LDAPOpCacheEntries"+                               , "LDAPOpCacheTTL"+                               , "LDAPSharedCacheSize"+                               , "LimitInternalRecursion"+                               , "LimitRequestBody"+                               , "LimitRequestFields"+                               , "LimitRequestFieldsize"+                               , "LimitRequestLine"+                               , "LimitXMLRequestBody"+                               , "ListenBacklog"+                               , "MaxClients"+                               , "MaxKeepAliveRequests"+                               , "MaxMemFree"+                               , "MaxRequestsPerChild"+                               , "MaxRequestsPerThread"+                               , "MaxSpareServers"+                               , "MaxSpareThreads"+                               , "MaxThreads"+                               , "MaxThreadsPerChild"+                               , "MCacheMaxObjectCount"+                               , "MCacheMaxObjectSize"+                               , "MCacheMaxStreamingBuffer"+                               , "MCacheMinObjectSize"+                               , "MCacheSize"+                               , "MinSpareServers"+                               , "MinSpareThreads"+                               , "NumServers"+                               , "ProxyIOBufferSize"+                               , "ProxyMaxForwards"+                               , "ProxyReceiveBufferSize"+                               , "ProxyTimeout"+                               , "RewriteLogLevel"+                               , "RLimitCPU"+                               , "RLimitMEM"+                               , "RLimitNPROC"+                               , "ScriptLogBuffer"+                               , "ScriptLogLength"+                               , "SendBufferSize"+                               , "ServerLimit"+                               , "SSLProxyVerifyDepth"+                               , "SSLSessionCacheTimeout"+                               , "SSLVerifyDepth"+                               , "StartServers"+                               , "StartThreads"+                               , "ThreadLimit"+                               , "ThreadsPerChild"+                               , "ThreadStackSize"+                               , "TimeOut"+                               ])+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Apache Configuration" , "Integer Directives" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "AcceptMutex"+                               , "AcceptPathInfo"+                               , "AllowEncodedSlashes"+                               , "AllowOverride"+                               , "Anonymous_Authoritative"+                               , "Anonymous_LogEmail"+                               , "Anonymous_MustGiveEmail"+                               , "Anonymous_NoUserID"+                               , "Anonymous_VerifyEmail"+                               , "AuthAuthoritative"+                               , "AuthBasicAuthoritative"+                               , "AuthBasicProvider"+                               , "AuthDBMAuthoritative"+                               , "AuthDBMType"+                               , "AuthDefaultAuthoritative"+                               , "AuthDigestAlgorithm"+                               , "AuthDigestNcCheck"+                               , "AuthDigestQop"+                               , "AuthLDAPAuthoritative"+                               , "AuthLDAPCompareDNOnServer"+                               , "AuthLDAPDereferenceAliases"+                               , "AuthLDAPEnabled"+                               , "AuthLDAPFrontPageHack"+                               , "AuthLDAPGroupAttributeIsDN"+                               , "AuthLDAPRemoteUserIsDN"+                               , "AuthType"+                               , "AuthzDBMAuthoritative"+                               , "AuthzDBMType"+                               , "AuthzDefaultAuthoritative"+                               , "AuthzGroupFileAuthoritative"+                               , "AuthzLDAPAuthoritative"+                               , "AuthzOwnerAuthoritative"+                               , "AuthzUserAuthoritative"+                               , "BufferedLogs"+                               , "CacheExpiryCheck"+                               , "CacheIgnoreCacheControl"+                               , "CacheIgnoreHeaders"+                               , "CacheIgnoreNoLastMod"+                               , "CacheNegotiatedDocs"+                               , "CacheStoreNoStore"+                               , "CacheStorePrivate"+                               , "CheckSpelling"+                               , "ContentDigest"+                               , "CookieStyle"+                               , "CookieTracking"+                               , "CoreDumpDirectory"+                               , "CustomLog"+                               , "DavDepthInfinity"+                               , "DirectorySlash"+                               , "DumpIOInput"+                               , "DumpIOOutput"+                               , "EnableExceptionHook"+                               , "EnableMMAP"+                               , "EnableSendfile"+                               , "ExpiresActive"+                               , "ExtendedStatus"+                               , "FileETag"+                               , "ForceLanguagePriority"+                               , "HostnameLookups"+                               , "IdentityCheck"+                               , "ImapDefault"+                               , "ImapMenu"+                               , "IndexOrderDefault"+                               , "ISAPIAppendLogToErrors"+                               , "ISAPIAppendLogToQuery"+                               , "ISAPIFakeAsync"+                               , "ISAPILogNotSupported"+                               , "KeepAlive"+                               , "LDAPTrustedMode"+                               , "LDAPVerifyServerCert"+                               , "LogLevel"+                               , "MCacheRemovalAlgorithm"+                               , "MetaFiles"+                               , "ModMimeUsePathInfo"+                               , "MultiviewsMatch"+                               , "Options"+                               , "Order"+                               , "ProtocolEcho"+                               , "ProxyBadHeader"+                               , "ProxyErrorOverride"+                               , "ProxyPreserveHost"+                               , "ProxyRequests"+                               , "ProxyVia"+                               , "RewriteEngine"+                               , "RewriteOptions"+                               , "Satisfy"+                               , "ScriptInterpreterSource"+                               , "ServerSignature"+                               , "ServerTokens"+                               , "SSLEngine"+                               , "SSLMutex"+                               , "SSLOptions"+                               , "SSLProtocol"+                               , "SSLProxyEngine"+                               , "SSLProxyVerify"+                               , "SSLSessionCache"+                               , "SSLVerifyClient"+                               , "UseCanonicalName"+                               , "XBitHack"+                               ])+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Apache Configuration" , "Alternative Directives" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\w+"+                              , reCompiled = Just (compileRegex True "<\\w+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Apache Configuration" , "Container Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</\\w+"+                              , reCompiled = Just (compileRegex True "</\\w+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Apache Configuration" , "Container Close" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Apache Configuration" , "Comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Jan Janssen (medhefgo@googlemail.com)"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions =+      [ "httpd.conf"+      , "httpd2.conf"+      , "apache.conf"+      , "apache2.conf"+      , ".htaccess*"+      , ".htpasswd*"+      ]+  , sStartingContext = "apache"+  }
+ src/Skylighting/Syntax/Asn1.hs view
@@ -0,0 +1,129 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Asn1 (syntax) where++import Skylighting.Types+import Data.Map+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "ASN.1"+  , sFilename = "asn1.xml"+  , sShortname = "Asn1"+  , sContexts =+      fromList+        [ ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "ASN.1"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal Text"+          , Context+              { cName = "Normal Text"+              , cSyntax = "ASN.1"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "APPLICATION"+                               , "BEGIN"+                               , "DEFAULT"+                               , "DEFINITIONS"+                               , "END"+                               , "EXPORTS"+                               , "FALSE"+                               , "FROM"+                               , "IMPORTS"+                               , "OPTIONAL"+                               , "PRIVATE"+                               , "TRUE"+                               , "UNIVERSAL"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "BOOLEAN"+                               , "CHOICE"+                               , "ENUMERATED"+                               , "INTEGER"+                               , "NULL"+                               , "OCTET STRING"+                               , "OF"+                               , "REAL"+                               , "SEQUENCE"+                               , "SET"+                               , "StringStore"+                               , "VisibleString"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '-' '-'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASN.1" , "Comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Philippe Rigault"+  , sVersion = "2"+  , sLicense = "GPL"+  , sExtensions = [ "*.asn" , "*.asn1" ]+  , sStartingContext = "Normal Text"+  }
+ src/Skylighting/Syntax/Asp.hs view
@@ -0,0 +1,1964 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Asp (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "ASP"+  , sFilename = "asp.xml"+  , sShortname = "Asp"+  , sContexts =+      fromList+        [ ( "asp_onelinecomment"+          , Context+              { cName = "asp_onelinecomment"+              , cSyntax = "ASP"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "%>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "aspsource"+          , Context+              { cName = "aspsource"+              , cSyntax = "ASP"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "%>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\s*\\/\\s*script\\s*>"+                              , reCompiled = Just (compileRegex False "<\\s*\\/\\s*script\\s*>")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "asp_onelinecomment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "doublequotestring" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "singlequotestring" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '&'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ""+                              , reCompiled = Just (compileRegex True "")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[0123456789]*\\.\\.\\.[0123456789]*"+                              , reCompiled =+                                  Just (compileRegex True "[0123456789]*\\.\\.\\.[0123456789]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar ";()}{:,[]"+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\belseif\\b"+                              , reCompiled = Just (compileRegex False "\\belseif\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\belse\\b"+                              , reCompiled = Just (compileRegex False "\\belse\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bif\\b"+                              , reCompiled = Just (compileRegex False "\\bif\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bend if\\b"+                              , reCompiled = Just (compileRegex False "\\bend if\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bexit function\\b"+                              , reCompiled = Just (compileRegex False "\\bexit function\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bfunction\\b"+                              , reCompiled = Just (compileRegex False "\\bfunction\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bend function\\b"+                              , reCompiled = Just (compileRegex False "\\bend function\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bexit sub\\b"+                              , reCompiled = Just (compileRegex False "\\bexit sub\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bsub\\b"+                              , reCompiled = Just (compileRegex False "\\bsub\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bend sub\\b"+                              , reCompiled = Just (compileRegex False "\\bend sub\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bclass\\b"+                              , reCompiled = Just (compileRegex False "\\bclass\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bend class\\b"+                              , reCompiled = Just (compileRegex False "\\bend class\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bexit do\\b"+                              , reCompiled = Just (compileRegex False "\\bexit do\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bdo(\\s+(while))?\\b"+                              , reCompiled = Just (compileRegex False "\\bdo(\\s+(while))?\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bloop\\b"+                              , reCompiled = Just (compileRegex False "\\bloop\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bexit while\\b"+                              , reCompiled = Just (compileRegex False "\\bexit while\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bwhile\\b"+                              , reCompiled = Just (compileRegex False "\\bwhile\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bwend\\b"+                              , reCompiled = Just (compileRegex False "\\bwend\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bexit for\\b"+                              , reCompiled = Just (compileRegex False "\\bexit for\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bfor\\b"+                              , reCompiled = Just (compileRegex False "\\bfor\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bnext\\b"+                              , reCompiled = Just (compileRegex False "\\bnext\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bselect case\\b"+                              , reCompiled = Just (compileRegex False "\\bselect case\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bend select\\b"+                              , reCompiled = Just (compileRegex False "\\bend select\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "and"+                               , "call"+                               , "class"+                               , "close"+                               , "const"+                               , "dim"+                               , "eof"+                               , "erase"+                               , "execute"+                               , "false"+                               , "function"+                               , "me"+                               , "movenext"+                               , "new"+                               , "not"+                               , "nothing"+                               , "open"+                               , "or"+                               , "preserve"+                               , "private"+                               , "public"+                               , "randomize"+                               , "redim"+                               , "set"+                               , "sub"+                               , "true"+                               , "with"+                               , "xor"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "case"+                               , "continue"+                               , "do"+                               , "each"+                               , "else"+                               , "elseif"+                               , "end if"+                               , "end select"+                               , "exit"+                               , "for"+                               , "if"+                               , "in"+                               , "loop"+                               , "next"+                               , "select"+                               , "then"+                               , "to"+                               , "until"+                               , "wend"+                               , "while"+                               ])+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "abs"+                               , "Add"+                               , "AddFolders"+                               , "array"+                               , "asc"+                               , "atn"+                               , "BuildPath"+                               , "cbool"+                               , "cbyte"+                               , "ccur"+                               , "cdate"+                               , "cdbl"+                               , "chr"+                               , "cint"+                               , "Clear"+                               , "clng"+                               , "Close"+                               , "cookies"+                               , "Copy"+                               , "CopyFile"+                               , "CopyFolder"+                               , "cos"+                               , "CreateFolder"+                               , "createobject"+                               , "CreateTextFile"+                               , "csng"+                               , "cstr"+                               , "date"+                               , "dateadd"+                               , "DateDiff"+                               , "DatePart"+                               , "DateSerial"+                               , "DateValue"+                               , "Day"+                               , "Delete"+                               , "DeleteFile"+                               , "DeleteFolder"+                               , "DriveExists"+                               , "end"+                               , "Exists"+                               , "Exp"+                               , "FileExists"+                               , "Filter"+                               , "Fix"+                               , "FolderExists"+                               , "form"+                               , "FormatCurrency"+                               , "FormatDateTime"+                               , "FormatNumber"+                               , "FormatPercent"+                               , "GetAbsolutePathName"+                               , "GetBaseName"+                               , "GetDrive"+                               , "GetDriveName"+                               , "GetExtensionName"+                               , "GetFile"+                               , "GetFileName"+                               , "GetFolder"+                               , "GetObject"+                               , "GetParentFolderName"+                               , "GetSpecialFolder"+                               , "GetTempName"+                               , "Hex"+                               , "Hour"+                               , "InputBox"+                               , "InStr"+                               , "InStrRev"+                               , "Int"+                               , "IsArray"+                               , "IsDate"+                               , "IsEmpty"+                               , "IsNull"+                               , "IsNumeric"+                               , "IsObject"+                               , "item"+                               , "Items"+                               , "Join"+                               , "Keys"+                               , "LBound"+                               , "LCase"+                               , "Left"+                               , "Len"+                               , "LoadPicture"+                               , "Log"+                               , "LTrim"+                               , "Mid"+                               , "Minute"+                               , "Month"+                               , "MonthName"+                               , "Move"+                               , "MoveFile"+                               , "MoveFolder"+                               , "MsgBox"+                               , "Now"+                               , "Oct"+                               , "OpenAsTextStream"+                               , "OpenTextFile"+                               , "querystring"+                               , "Raise"+                               , "Read"+                               , "ReadAll"+                               , "ReadLine"+                               , "redirect"+                               , "Remove"+                               , "RemoveAll"+                               , "Replace"+                               , "request"+                               , "response"+                               , "RGB"+                               , "Right"+                               , "Rnd"+                               , "Round"+                               , "RTrim"+                               , "ScriptEngine"+                               , "ScriptEngineBuildVersion"+                               , "ScriptEngineMajorVersion"+                               , "ScriptEngineMinorVersion"+                               , "Second"+                               , "server"+                               , "servervariables"+                               , "session"+                               , "Sgn"+                               , "Sin"+                               , "Skip"+                               , "SkipLine"+                               , "Space"+                               , "Split"+                               , "Sqr"+                               , "StrComp"+                               , "String"+                               , "StrReverse"+                               , "Tan"+                               , "Time"+                               , "Timer"+                               , "TimeSerial"+                               , "TimeValue"+                               , "Trim"+                               , "TypeName"+                               , "UBound"+                               , "UCase"+                               , "VarType"+                               , "Weekday"+                               , "WeekdayName"+                               , "write"+                               , "WriteBlankLines"+                               , "WriteLine"+                               , "Year"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "doublequotestring"+          , Context+              { cName = "doublequotestring"+              , cSyntax = "ASP"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '"' '"'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[0-7]{1,3}"+                              , reCompiled = Just (compileRegex True "\\\\[0-7]{1,3}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\x[0-9A-Fa-f]{1,2}"+                              , reCompiled = Just (compileRegex True "\\\\x[0-9A-Fa-f]{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "htmlcomment"+          , Context+              { cName = "htmlcomment"+              , cSyntax = "ASP"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<%"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "aspsource" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<%"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "aspsource" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "-->"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*=\\s*"+                              , reCompiled = Just (compileRegex True "\\s*=\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "identifiers" ) ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "htmltag"+          , Context+              { cName = "htmltag"+              , cSyntax = "ASP"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<%"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "aspsource" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<%"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "aspsource" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*=\\s*"+                              , reCompiled = Just (compileRegex True "\\s*=\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "identifiers" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "identifiers"+          , Context+              { cName = "identifiers"+              , cSyntax = "ASP"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*#?[a-zA-Z0-9]*"+                              , reCompiled = Just (compileRegex True "\\s*#?[a-zA-Z0-9]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "types1" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "types2" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "nosource"+          , Context+              { cName = "nosource"+              , cSyntax = "ASP"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<%"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "aspsource" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\s*script\\s*language=\"VBScript\"[^>]*>"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False "<\\s*script\\s*language=\"VBScript\"[^>]*>")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "aspsource" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\s*script(\\s|>)"+                              , reCompiled = Just (compileRegex False "<\\s*script(\\s|>)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "scripts" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\s*\\/?\\s*[a-zA-Z_:][a-zA-Z0-9._:-]*"+                              , reCompiled =+                                  Just (compileRegex True "<\\s*\\/?\\s*[a-zA-Z_:][a-zA-Z0-9._:-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "htmltag" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "htmlcomment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "scripts"+          , Context+              { cName = "scripts"+              , cSyntax = "ASP"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "scripts_onelinecomment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "twolinecomment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "case"+                               , "continue"+                               , "do"+                               , "each"+                               , "else"+                               , "elseif"+                               , "end if"+                               , "end select"+                               , "exit"+                               , "for"+                               , "if"+                               , "in"+                               , "loop"+                               , "next"+                               , "select"+                               , "then"+                               , "to"+                               , "until"+                               , "wend"+                               , "while"+                               ])+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "and"+                               , "call"+                               , "class"+                               , "close"+                               , "const"+                               , "dim"+                               , "eof"+                               , "erase"+                               , "execute"+                               , "false"+                               , "function"+                               , "me"+                               , "movenext"+                               , "new"+                               , "not"+                               , "nothing"+                               , "open"+                               , "or"+                               , "preserve"+                               , "private"+                               , "public"+                               , "randomize"+                               , "redim"+                               , "set"+                               , "sub"+                               , "true"+                               , "with"+                               , "xor"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "abs"+                               , "Add"+                               , "AddFolders"+                               , "array"+                               , "asc"+                               , "atn"+                               , "BuildPath"+                               , "cbool"+                               , "cbyte"+                               , "ccur"+                               , "cdate"+                               , "cdbl"+                               , "chr"+                               , "cint"+                               , "Clear"+                               , "clng"+                               , "Close"+                               , "cookies"+                               , "Copy"+                               , "CopyFile"+                               , "CopyFolder"+                               , "cos"+                               , "CreateFolder"+                               , "createobject"+                               , "CreateTextFile"+                               , "csng"+                               , "cstr"+                               , "date"+                               , "dateadd"+                               , "DateDiff"+                               , "DatePart"+                               , "DateSerial"+                               , "DateValue"+                               , "Day"+                               , "Delete"+                               , "DeleteFile"+                               , "DeleteFolder"+                               , "DriveExists"+                               , "end"+                               , "Exists"+                               , "Exp"+                               , "FileExists"+                               , "Filter"+                               , "Fix"+                               , "FolderExists"+                               , "form"+                               , "FormatCurrency"+                               , "FormatDateTime"+                               , "FormatNumber"+                               , "FormatPercent"+                               , "GetAbsolutePathName"+                               , "GetBaseName"+                               , "GetDrive"+                               , "GetDriveName"+                               , "GetExtensionName"+                               , "GetFile"+                               , "GetFileName"+                               , "GetFolder"+                               , "GetObject"+                               , "GetParentFolderName"+                               , "GetSpecialFolder"+                               , "GetTempName"+                               , "Hex"+                               , "Hour"+                               , "InputBox"+                               , "InStr"+                               , "InStrRev"+                               , "Int"+                               , "IsArray"+                               , "IsDate"+                               , "IsEmpty"+                               , "IsNull"+                               , "IsNumeric"+                               , "IsObject"+                               , "item"+                               , "Items"+                               , "Join"+                               , "Keys"+                               , "LBound"+                               , "LCase"+                               , "Left"+                               , "Len"+                               , "LoadPicture"+                               , "Log"+                               , "LTrim"+                               , "Mid"+                               , "Minute"+                               , "Month"+                               , "MonthName"+                               , "Move"+                               , "MoveFile"+                               , "MoveFolder"+                               , "MsgBox"+                               , "Now"+                               , "Oct"+                               , "OpenAsTextStream"+                               , "OpenTextFile"+                               , "querystring"+                               , "Raise"+                               , "Read"+                               , "ReadAll"+                               , "ReadLine"+                               , "redirect"+                               , "Remove"+                               , "RemoveAll"+                               , "Replace"+                               , "request"+                               , "response"+                               , "RGB"+                               , "Right"+                               , "Rnd"+                               , "Round"+                               , "RTrim"+                               , "ScriptEngine"+                               , "ScriptEngineBuildVersion"+                               , "ScriptEngineMajorVersion"+                               , "ScriptEngineMinorVersion"+                               , "Second"+                               , "server"+                               , "servervariables"+                               , "session"+                               , "Sgn"+                               , "Sin"+                               , "Skip"+                               , "SkipLine"+                               , "Space"+                               , "Split"+                               , "Sqr"+                               , "StrComp"+                               , "String"+                               , "StrReverse"+                               , "Tan"+                               , "Time"+                               , "Timer"+                               , "TimeSerial"+                               , "TimeValue"+                               , "Trim"+                               , "TypeName"+                               , "UBound"+                               , "UCase"+                               , "VarType"+                               , "Weekday"+                               , "WeekdayName"+                               , "write"+                               , "WriteBlankLines"+                               , "WriteLine"+                               , "Year"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<%"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "aspsource" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\s*\\/\\s*script\\s*>"+                              , reCompiled = Just (compileRegex False "<\\s*\\/\\s*script\\s*>")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "doublequotestring" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "singlequotestring" ) ]+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar ";()}{:,[]"+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "scripts_onelinecomment"+          , Context+              { cName = "scripts_onelinecomment"+              , cSyntax = "ASP"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\s*\\/\\s*script\\s*>"+                              , reCompiled = Just (compileRegex False "<\\s*\\/\\s*script\\s*>")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "singlequotestring"+          , Context+              { cName = "singlequotestring"+              , cSyntax = "ASP"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\'' '\''+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "twolinecomment"+          , Context+              { cName = "twolinecomment"+              , cSyntax = "ASP"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "types1"+          , Context+              { cName = "types1"+              , cSyntax = "ASP"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<%"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "aspsource" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<%"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "aspsource" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "types2"+          , Context+              { cName = "types2"+              , cSyntax = "ASP"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<%"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "aspsource" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<%"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ASP" , "aspsource" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Antonio Salazar (savedfastcool@gmail.com)"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions = [ "*.asp" ]+  , sStartingContext = "nosource"+  }
+ src/Skylighting/Syntax/Ats.hs view
@@ -0,0 +1,716 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Ats (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "ATS"+  , sFilename = "ats.xml"+  , sShortname = "Ats"+  , sContexts =+      fromList+        [ ( "Existential Context"+          , Context+              { cName = "Existential Context"+              , cSyntax = "ATS"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Function Keyword Context"+          , Context+              { cName = "Function Keyword Context"+              , cSyntax = "ATS"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ATS" , "Universal Context" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ATS" , "Existential Context" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "ATS" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Multiline C-style Comment"+          , Context+              { cName = "Multiline C-style Comment"+              , cSyntax = "ATS"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Multiline Comment"+          , Context+              { cName = "Multiline Comment"+              , cSyntax = "ATS"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' ')'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '(' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ATS" , "Multiline Comment" ) ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "ATS"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "////"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ATS" , "Rest-of-file Comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '(' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ATS" , "Multiline Comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ATS" , "Multiline C-style Comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "ATS" , "Singleline C++ style Comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '.' '<'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "ATS" , "Termination Metrics Context" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "`\\s*[A-Za-z\\300-\\326\\330-\\366\\370-\\377_][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "`\\s*[A-Za-z\\300-\\326\\330-\\366\\370-\\377_][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "absprop"+                               , "abst0ype"+                               , "abstype"+                               , "absview"+                               , "absviewt0ype"+                               , "absviewtype"+                               , "absvt0ype"+                               , "absvtype"+                               , "and"+                               , "as"+                               , "assume"+                               , "begin"+                               , "break"+                               , "classdec"+                               , "continue"+                               , "dataprop"+                               , "datasort"+                               , "datatype"+                               , "dataview"+                               , "dataviewtype"+                               , "datavtype"+                               , "do"+                               , "dynload"+                               , "else"+                               , "end"+                               , "exception"+                               , "extern"+                               , "extval"+                               , "extype"+                               , "for"+                               , "if"+                               , "in"+                               , "infix"+                               , "infixl"+                               , "infixr"+                               , "let"+                               , "local"+                               , "macdef"+                               , "macrodef"+                               , "nonfix"+                               , "of"+                               , "op"+                               , "overload"+                               , "postfix"+                               , "prefix"+                               , "propdef"+                               , "prval"+                               , "prvar"+                               , "rec"+                               , "scase"+                               , "sif"+                               , "sortdef"+                               , "sta"+                               , "stacst"+                               , "stadef"+                               , "staload"+                               , "stavar"+                               , "symelim"+                               , "symintr"+                               , "then"+                               , "tkindef"+                               , "try"+                               , "type"+                               , "typedef"+                               , "val"+                               , "var"+                               , "viewdef"+                               , "viewtypedef"+                               , "vtypedef"+                               , "when"+                               , "where"+                               , "while"+                               , "with"+                               , "withprop"+                               , "withtype"+                               , "withview"+                               , "withviewtype"+                               , "withvtype"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "castfn"+                               , "fix"+                               , "fn"+                               , "fnx"+                               , "fun"+                               , "implement"+                               , "implmnt"+                               , "lam"+                               , "llam"+                               , "praxi"+                               , "prfn"+                               , "prfun"+                               , "primplement"+                               , "primplmnt"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ATS" , "Function Keyword Context" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "#assert"+                               , "#define"+                               , "#elif"+                               , "#elifdef"+                               , "#elifndef"+                               , "#else"+                               , "#endif"+                               , "#error"+                               , "#if"+                               , "#ifdef"+                               , "#ifndef"+                               , "#include"+                               , "#print"+                               , "#then"+                               , "#undef"+                               , "$arrpsz"+                               , "$arrptrsize"+                               , "$delay"+                               , "$effmask"+                               , "$effmask_all"+                               , "$effmask_exn"+                               , "$effmask_ntm"+                               , "$effmask_ref"+                               , "$effmask_wrt"+                               , "$extern"+                               , "$extkind"+                               , "$extval"+                               , "$extype"+                               , "$extype_struct"+                               , "$ldelay"+                               , "$list"+                               , "$list_t"+                               , "$list_vt"+                               , "$lst"+                               , "$lst_t"+                               , "$lst_vt"+                               , "$myfilename"+                               , "$myfunction"+                               , "$mylocation"+                               , "$raise"+                               , "$rec"+                               , "$rec_t"+                               , "$rec_vt"+                               , "$record"+                               , "$record_t"+                               , "$record_vt"+                               , "$showtype"+                               , "$tup"+                               , "$tup_t"+                               , "$tup_vt"+                               , "$tuple"+                               , "$tuple_t"+                               , "$tuple_vt"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "[A-Za-z\\300-\\326\\330-\\366\\370-\\377_][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "[A-Za-z\\300-\\326\\330-\\366\\370-\\377_][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "~?0[xX][0-9A-Fa-f_]+"+                              , reCompiled = Just (compileRegex True "~?0[xX][0-9A-Fa-f_]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "~?[0-9][0-9_]*((\\.([0-9][0-9_]*)?([eE][-+]?[0-9][0-9_]*)?)|([eE][-+]?[0-9][0-9_]*))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "~?[0-9][0-9_]*((\\.([0-9][0-9_]*)?([eE][-+]?[0-9][0-9_]*)?)|([eE][-+]?[0-9][0-9_]*))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "~?[0-9][0-9_]*"+                              , reCompiled = Just (compileRegex True "~?[0-9][0-9_]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Rest-of-file Comment"+          , Context+              { cName = "Rest-of-file Comment"+              , cSyntax = "ATS"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Singleline C++ style Comment"+          , Context+              { cName = "Singleline C++ style Comment"+              , cSyntax = "ATS"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String Context"+          , Context+              { cName = "String Context"+              , cSyntax = "ATS"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\\\[ntbr'\"\\\\]|\\\\[0-9]{3}|\\\\x[0-9A-Fa-f]{2})"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(\\\\[ntbr'\"\\\\]|\\\\[0-9]{3}|\\\\x[0-9A-Fa-f]{2})")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\$"+                              , reCompiled = Just (compileRegex True "\\\\$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Termination Metrics Context"+          , Context+              { cName = "Termination Metrics Context"+              , cSyntax = "ATS"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '>' '.'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Universal Context"+          , Context+              { cName = "Universal Context"+              , cSyntax = "ATS"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Kiwamu Okabe (kiwamu@debian.or.jp)"+  , sVersion = "0.01"+  , sLicense = "LGPL"+  , sExtensions = [ "*.dats" , "*.sats" , "*.hats" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Awk.hs view
@@ -0,0 +1,1089 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Awk (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "AWK"+  , sFilename = "awk.xml"+  , sShortname = "Awk"+  , sContexts =+      fromList+        [ ( "Block"+          , Context+              { cName = "Block"+              , cSyntax = "AWK"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "Block" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "AWK" , "base" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "BEGIN" , "END" ])+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CharClass"+          , Context+              { cName = "CharClass"+              , cSyntax = "AWK"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(alpha|alnum|blank|cntrl|digit|graph|lower|punct|space|upper|xdigit)(?=:\\])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(alpha|alnum|blank|cntrl|digit|graph|lower|punct|space|upper|xdigit)(?=:\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars ':' ']'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CheckRange"+          , Context+              { cName = "CheckRange"+              , cSyntax = "AWK"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*,\\s*(?=/)"+                              , reCompiled = Just (compileRegex True "\\s*,\\s*(?=/)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "RangePattern" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop , Pop , Pop ]+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "AWK"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Escape"+          , Context+              { cName = "Escape"+              , cSyntax = "AWK"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "InChar"+          , Context+              { cName = "InChar"+              , cSyntax = "AWK"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "Regex Escape" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '-' ']'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "Regex Escape" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '-'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[:(?=[_\\w][_\\d\\w]*:\\])"+                              , reCompiled =+                                  Just (compileRegex True "\\[:(?=[_\\w][_\\d\\w]*:\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "CharClass" ) ]+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Match"+          , Context+              { cName = "Match"+              , cSyntax = "AWK"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '^'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "Regex" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '/'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "Regex" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "MatchPattern"+          , Context+              { cName = "MatchPattern"+              , cSyntax = "AWK"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '^'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "RegexPattern" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '/'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "RegexPattern" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "Pattern"+          , Context+              { cName = "Pattern"+              , cSyntax = "AWK"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "Block" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '/'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "MatchPattern" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "AWK" , "base" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "BEGIN" , "END" ])+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Pattern2"+          , Context+              { cName = "Pattern2"+              , cSyntax = "AWK"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "AWK" , "regex" )+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '/'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RangePattern"+          , Context+              { cName = "RangePattern"+              , cSyntax = "AWK"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '^'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "Pattern2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '/'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "Pattern2" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop , Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop , Pop , Pop , Pop ]+              , cDynamic = False+              }+          )+        , ( "Regex"+          , Context+              { cName = "Regex"+              , cSyntax = "AWK"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "AWK" , "regex" )+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '/'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Regex Escape"+          , Context+              { cName = "Regex Escape"+              , cSyntax = "AWK"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RegexChar"+          , Context+              { cName = "RegexChar"+              , cSyntax = "AWK"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '-' ']'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "InChar" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "-]"+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "InChar" ) ]+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Push ( "AWK" , "InChar" ) ]+              , cDynamic = False+              }+          )+        , ( "RegexPattern"+          , Context+              { cName = "RegexPattern"+              , cSyntax = "AWK"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "AWK" , "regex" )+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '/'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "CheckRange" ) ]+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "AWK"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "Escape" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "base"+          , Context+              { cName = "base"+              , cSyntax = "AWK"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '~'+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "Match" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "!%&*+,-./:;<=>?^|"+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "break"+                               , "continue"+                               , "do"+                               , "else"+                               , "exit"+                               , "for"+                               , "function"+                               , "getline"+                               , "if"+                               , "in"+                               , "next"+                               , "print"+                               , "printf"+                               , "return"+                               , "while"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ARGC"+                               , "ARGV"+                               , "CONVFMT"+                               , "ENVIRON"+                               , "FILENAME"+                               , "FNR"+                               , "FS"+                               , "NF"+                               , "NR"+                               , "OFMT"+                               , "OFS"+                               , "ORS"+                               , "RLENGTH"+                               , "RS"+                               , "RSTART"+                               , "SUBSEP"+                               ])+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "atan2"+                               , "close"+                               , "cos"+                               , "exp"+                               , "fflush"+                               , "gensub"+                               , "gsub"+                               , "index"+                               , "int"+                               , "length"+                               , "log"+                               , "match"+                               , "rand"+                               , "sin"+                               , "split"+                               , "sprintf"+                               , "sqrt"+                               , "srand"+                               , "sub"+                               , "substr"+                               , "system"+                               , "tolower"+                               , "toupper"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[A-Za-z0-9_]+"+                              , reCompiled = Just (compileRegex True "\\$[A-Za-z0-9_]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "regex"+          , Context+              { cName = "regex"+              , cSyntax = "AWK"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "Regex Escape" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '[' '^'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "RegexChar" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "AWK" , "RegexChar" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "$.+?*()|"+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = ""+  , sVersion = "1"+  , sLicense = "LGPL"+  , sExtensions = [ "*.awk" ]+  , sStartingContext = "Pattern"+  }
+ src/Skylighting/Syntax/Bash.hs view
@@ -0,0 +1,5234 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Bash (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Bash"+  , sFilename = "bash.xml"+  , sShortname = "Bash"+  , sContexts =+      fromList+        [ ( "Assign"+          , Context+              { cName = "Assign"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "AssignArray" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\w:,+_./-]"+                              , reCompiled = Just (compileRegex True "[\\w:,+_./-]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "AssignArray"+          , Context+              { cName = "AssignArray"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "Subscript" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "Assign" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "AssignSubscr"+          , Context+              { cName = "AssignSubscr"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "Subscript" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '+' '='+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "Assign" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "Assign" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "Case"+          , Context+              { cName = "Case"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\sin\\b"+                              , reCompiled = Just (compileRegex True "\\sin\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "CaseIn" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CaseExpr"+          , Context+              { cName = "CaseExpr"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars ';' ';'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "esac(?=$|[\\s;)])"+                              , reCompiled = Just (compileRegex True "esac(?=$|[\\s;)])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindAll" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CaseIn"+          , Context+              { cName = "CaseIn"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\besac(?=$|[\\s;)])"+                              , reCompiled = Just (compileRegex True "\\besac(?=$|[\\s;)])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "CaseExpr" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "(|"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CommandArgs"+          , Context+              { cName = "CommandArgs"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\$"+                              , reCompiled = Just (compileRegex True "\\\\$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.(?=\\s)"+                              , reCompiled = Just (compileRegex True "\\.(?=\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\d*<<<"+                              , reCompiled = Just (compileRegex True "\\d*<<<")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<<"+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "HereDoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[<>]\\("+                              , reCompiled = Just (compileRegex True "[<>]\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "ProcessSubst" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([0-9]*(>{1,2}|<)(&[0-9]+-?)?|&>|>&|[0-9]*<>)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "([0-9]*(>{1,2}|<)(&[0-9]+-?)?|&>|>&|[0-9]*<>)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([|&;])\\1?"+                              , reCompiled = Just (compileRegex True "([|&;])\\1?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-?-[a-z][A-Za-z0-9_-]*"+                              , reCompiled = Just (compileRegex True "-?-[a-z][A-Za-z0-9_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,;<=>?\\`|~"+                              }+                            (makeWordSet+                               True+                               [ "elif"+                               , "else"+                               , "for"+                               , "function"+                               , "in"+                               , "select"+                               , "set"+                               , "then"+                               , "until"+                               , "while"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar ")}"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CommandArgsBackq"+          , Context+              { cName = "CommandArgsBackq"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "CommandArgs" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Modelines" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CommentBackq"+          , Context+              { cName = "CommentBackq"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^`](?=`)"+                              , reCompiled = Just (compileRegex True "[^`](?=`)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CommentParen"+          , Context+              { cName = "CommentParen"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^)](?=\\))"+                              , reCompiled = Just (compileRegex True "[^)](?=\\))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ExprBracket"+          , Context+              { cName = "ExprBracket"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s\\](?=($|[\\s;|&]))"+                              , reCompiled = Just (compileRegex True "\\s\\](?=($|[\\s;|&]))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\](?=($|[\\s;|&]))"+                              , reCompiled = Just (compileRegex True "\\](?=($|[\\s;|&]))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "ExprSubParen" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindTests" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ExprDblBracket"+          , Context+              { cName = "ExprDblBracket"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s\\]\\](?=($|[\\s;|&]))"+                              , reCompiled = Just (compileRegex True "\\s\\]\\](?=($|[\\s;|&]))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\]\\](?=($|[\\s;|&]))"+                              , reCompiled = Just (compileRegex True "\\]\\](?=($|[\\s;|&]))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "ExprSubParen" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindTests" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ExprDblParen"+          , Context+              { cName = "ExprDblParen"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars ')' ')'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "ExprSubParen" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ExprDblParenSubst"+          , Context+              { cName = "ExprDblParenSubst"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars ')' ')'+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "ExprSubParen" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ExprSubParen"+          , Context+              { cName = "ExprSubParen"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "ExprSubParen" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindAll"+          , Context+              { cName = "FindAll"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindComments" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindCommands" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindCommands"+          , Context+              { cName = "FindCommands"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindSpecialCommands" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindNormalCommands" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindCommandsBackq"+          , Context+              { cName = "FindCommandsBackq"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindSpecialCommands" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindNormalCommandsBackq" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindComments"+          , Context+              { cName = "FindComments"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\s;](?=#)"+                              , reCompiled = Just (compileRegex True "[\\s;](?=#)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "Comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindCommentsBackq"+          , Context+              { cName = "FindCommentsBackq"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "CommentBackq" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\s;](?=#)"+                              , reCompiled = Just (compileRegex True "[\\s;](?=#)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "CommentBackq" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindCommentsParen"+          , Context+              { cName = "FindCommentsParen"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "CommentParen" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\s;](?=#)"+                              , reCompiled = Just (compileRegex True "[\\s;](?=#)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "CommentParen" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindMost"+          , Context+              { cName = "FindMost"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindComments" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindNormalCommands"+          , Context+              { cName = "FindNormalCommands"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,;<=>?\\`|~"+                              }+                            (makeWordSet+                               True+                               [ ":"+                               , "alias"+                               , "bg"+                               , "bind"+                               , "break"+                               , "builtin"+                               , "caller"+                               , "cd"+                               , "command"+                               , "compgen"+                               , "complete"+                               , "continue"+                               , "dirs"+                               , "disown"+                               , "echo"+                               , "enable"+                               , "eval"+                               , "exec"+                               , "exit"+                               , "fc"+                               , "fg"+                               , "getopts"+                               , "hash"+                               , "help"+                               , "history"+                               , "jobs"+                               , "kill"+                               , "let"+                               , "logout"+                               , "popd"+                               , "printf"+                               , "pushd"+                               , "pwd"+                               , "return"+                               , "set"+                               , "shift"+                               , "shopt"+                               , "source"+                               , "suspend"+                               , "test"+                               , "time"+                               , "times"+                               , "trap"+                               , "type"+                               , "ulimit"+                               , "umask"+                               , "unalias"+                               , "wait"+                               ])+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "CommandArgs" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,;<=>?\\`|~"+                              }+                            (makeWordSet+                               True+                               [ "aclocal"+                               , "aconnect"+                               , "aplay"+                               , "apm"+                               , "apmsleep"+                               , "apropos"+                               , "ar"+                               , "arch"+                               , "arecord"+                               , "as"+                               , "as86"+                               , "autoconf"+                               , "autoheader"+                               , "automake"+                               , "awk"+                               , "basename"+                               , "bash"+                               , "bc"+                               , "bison"+                               , "bunzip2"+                               , "bzcat"+                               , "bzcmp"+                               , "bzdiff"+                               , "bzegrep"+                               , "bzfgrep"+                               , "bzgrep"+                               , "bzip2"+                               , "bzip2recover"+                               , "bzless"+                               , "bzmore"+                               , "c++"+                               , "cal"+                               , "cat"+                               , "cc"+                               , "cd-read"+                               , "cdda2wav"+                               , "cdparanoia"+                               , "cdrdao"+                               , "cdrecord"+                               , "chattr"+                               , "chfn"+                               , "chgrp"+                               , "chmod"+                               , "chown"+                               , "chroot"+                               , "chsh"+                               , "chvt"+                               , "clang"+                               , "clear"+                               , "cmake"+                               , "cmp"+                               , "co"+                               , "col"+                               , "comm"+                               , "cp"+                               , "cpio"+                               , "cpp"+                               , "cut"+                               , "date"+                               , "dc"+                               , "dcop"+                               , "dd"+                               , "deallocvt"+                               , "df"+                               , "diff"+                               , "diff3"+                               , "dir"+                               , "dircolors"+                               , "directomatic"+                               , "dirname"+                               , "dmesg"+                               , "dnsdomainname"+                               , "domainname"+                               , "du"+                               , "dumpkeys"+                               , "echo"+                               , "ed"+                               , "egrep"+                               , "env"+                               , "expr"+                               , "false"+                               , "fbset"+                               , "fgconsole"+                               , "fgrep"+                               , "file"+                               , "find"+                               , "flex"+                               , "flex++"+                               , "fmt"+                               , "free"+                               , "ftp"+                               , "funzip"+                               , "fuser"+                               , "g++"+                               , "gawk"+                               , "gc"+                               , "gcc"+                               , "gdb"+                               , "getent"+                               , "getkeycodes"+                               , "getopt"+                               , "gettext"+                               , "gettextize"+                               , "gimp"+                               , "gimp-remote"+                               , "gimptool"+                               , "git"+                               , "gmake"+                               , "gocr"+                               , "grep"+                               , "groff"+                               , "groups"+                               , "gs"+                               , "gunzip"+                               , "gzexe"+                               , "gzip"+                               , "head"+                               , "hexdump"+                               , "hostname"+                               , "id"+                               , "igawk"+                               , "install"+                               , "join"+                               , "kbd_mode"+                               , "kbdrate"+                               , "kdialog"+                               , "kfile"+                               , "kill"+                               , "killall"+                               , "last"+                               , "lastb"+                               , "ld"+                               , "ld86"+                               , "ldd"+                               , "less"+                               , "lex"+                               , "link"+                               , "ln"+                               , "loadkeys"+                               , "loadunimap"+                               , "locate"+                               , "lockfile"+                               , "login"+                               , "logname"+                               , "lp"+                               , "lpr"+                               , "ls"+                               , "lsattr"+                               , "lsmod"+                               , "lsmod.old"+                               , "lynx"+                               , "lzcat"+                               , "lzcmp"+                               , "lzdiff"+                               , "lzegrep"+                               , "lzfgrep"+                               , "lzgrep"+                               , "lzless"+                               , "lzma"+                               , "lzmainfo"+                               , "lzmore"+                               , "m4"+                               , "make"+                               , "man"+                               , "mapscrn"+                               , "mesg"+                               , "mkdir"+                               , "mkfifo"+                               , "mknod"+                               , "mktemp"+                               , "more"+                               , "mount"+                               , "msgfmt"+                               , "mv"+                               , "namei"+                               , "nano"+                               , "nasm"+                               , "nawk"+                               , "netstat"+                               , "nice"+                               , "nisdomainname"+                               , "nl"+                               , "nm"+                               , "nm86"+                               , "nmap"+                               , "nohup"+                               , "nop"+                               , "nroff"+                               , "od"+                               , "openvt"+                               , "passwd"+                               , "patch"+                               , "pcregrep"+                               , "pcretest"+                               , "perl"+                               , "perror"+                               , "pgawk"+                               , "pidof"+                               , "ping"+                               , "pr"+                               , "printf"+                               , "procmail"+                               , "prune"+                               , "ps"+                               , "ps2ascii"+                               , "ps2epsi"+                               , "ps2frag"+                               , "ps2pdf"+                               , "ps2ps"+                               , "psbook"+                               , "psmerge"+                               , "psnup"+                               , "psresize"+                               , "psselect"+                               , "pstops"+                               , "pstree"+                               , "pwd"+                               , "qmake"+                               , "rbash"+                               , "rcs"+                               , "readlink"+                               , "red"+                               , "resizecons"+                               , "rev"+                               , "rm"+                               , "rmdir"+                               , "rsync"+                               , "run-parts"+                               , "sash"+                               , "scp"+                               , "sed"+                               , "seq"+                               , "setfont"+                               , "setkeycodes"+                               , "setleds"+                               , "setmetamode"+                               , "setserial"+                               , "setterm"+                               , "sh"+                               , "showkey"+                               , "shred"+                               , "size"+                               , "size86"+                               , "skill"+                               , "sleep"+                               , "slogin"+                               , "snice"+                               , "sort"+                               , "sox"+                               , "split"+                               , "ssed"+                               , "ssh"+                               , "ssh-add"+                               , "ssh-agent"+                               , "ssh-keygen"+                               , "ssh-keyscan"+                               , "stat"+                               , "strings"+                               , "strip"+                               , "stty"+                               , "su"+                               , "sudo"+                               , "suidperl"+                               , "sum"+                               , "svn"+                               , "sync"+                               , "tac"+                               , "tail"+                               , "tar"+                               , "tee"+                               , "tempfile"+                               , "test"+                               , "touch"+                               , "tr"+                               , "troff"+                               , "true"+                               , "umount"+                               , "uname"+                               , "unicode_start"+                               , "unicode_stop"+                               , "uniq"+                               , "unlink"+                               , "unlzma"+                               , "unxz"+                               , "unzip"+                               , "updatedb"+                               , "updmap"+                               , "uptime"+                               , "users"+                               , "utmpdump"+                               , "uuidgen"+                               , "valgrind"+                               , "vdir"+                               , "vmstat"+                               , "w"+                               , "wall"+                               , "wc"+                               , "wget"+                               , "whatis"+                               , "whereis"+                               , "which"+                               , "who"+                               , "whoami"+                               , "write"+                               , "xargs"+                               , "xdg-open"+                               , "xhost"+                               , "xmodmap"+                               , "xset"+                               , "xz"+                               , "xzcat"+                               , "yacc"+                               , "yes"+                               , "ypdomainname"+                               , "zcat"+                               , "zcmp"+                               , "zdiff"+                               , "zegrep"+                               , "zfgrep"+                               , "zforce"+                               , "zgrep"+                               , "zip"+                               , "zless"+                               , "zmore"+                               , "znew"+                               , "zsh"+                               , "zsoelim"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "CommandArgs" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([\\w_@.%*?+-]|\\\\ )*(?=/)"+                              , reCompiled =+                                  Just (compileRegex True "([\\w_@.%*?+-]|\\\\ )*(?=/)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "~\\w*"+                              , reCompiled = Just (compileRegex True "~\\w*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/([\\w_@.%*?+-]|\\\\ )*(?=([/);$`'\"]|$))"+                              , reCompiled =+                                  Just+                                    (compileRegex True "/([\\w_@.%*?+-]|\\\\ )*(?=([/);$`'\"]|$))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/([\\w_@.%*?+-]|\\\\ )*(?=([\\s);$`'\"]|$))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "/([\\w_@.%*?+-]|\\\\ )*(?=([\\s);$`'\"]|$))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "CommandArgs" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([\\w_@.%*?+-]|\\\\ )*"+                              , reCompiled = Just (compileRegex True "([\\w_@.%*?+-]|\\\\ )*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "CommandArgs" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindNormalCommandsBackq"+          , Context+              { cName = "FindNormalCommandsBackq"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,;<=>?\\`|~"+                              }+                            (makeWordSet+                               True+                               [ ":"+                               , "alias"+                               , "bg"+                               , "bind"+                               , "break"+                               , "builtin"+                               , "caller"+                               , "cd"+                               , "command"+                               , "compgen"+                               , "complete"+                               , "continue"+                               , "dirs"+                               , "disown"+                               , "echo"+                               , "enable"+                               , "eval"+                               , "exec"+                               , "exit"+                               , "fc"+                               , "fg"+                               , "getopts"+                               , "hash"+                               , "help"+                               , "history"+                               , "jobs"+                               , "kill"+                               , "let"+                               , "logout"+                               , "popd"+                               , "printf"+                               , "pushd"+                               , "pwd"+                               , "return"+                               , "set"+                               , "shift"+                               , "shopt"+                               , "source"+                               , "suspend"+                               , "test"+                               , "time"+                               , "times"+                               , "trap"+                               , "type"+                               , "ulimit"+                               , "umask"+                               , "unalias"+                               , "wait"+                               ])+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "CommandArgsBackq" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,;<=>?\\`|~"+                              }+                            (makeWordSet+                               True+                               [ "aclocal"+                               , "aconnect"+                               , "aplay"+                               , "apm"+                               , "apmsleep"+                               , "apropos"+                               , "ar"+                               , "arch"+                               , "arecord"+                               , "as"+                               , "as86"+                               , "autoconf"+                               , "autoheader"+                               , "automake"+                               , "awk"+                               , "basename"+                               , "bash"+                               , "bc"+                               , "bison"+                               , "bunzip2"+                               , "bzcat"+                               , "bzcmp"+                               , "bzdiff"+                               , "bzegrep"+                               , "bzfgrep"+                               , "bzgrep"+                               , "bzip2"+                               , "bzip2recover"+                               , "bzless"+                               , "bzmore"+                               , "c++"+                               , "cal"+                               , "cat"+                               , "cc"+                               , "cd-read"+                               , "cdda2wav"+                               , "cdparanoia"+                               , "cdrdao"+                               , "cdrecord"+                               , "chattr"+                               , "chfn"+                               , "chgrp"+                               , "chmod"+                               , "chown"+                               , "chroot"+                               , "chsh"+                               , "chvt"+                               , "clang"+                               , "clear"+                               , "cmake"+                               , "cmp"+                               , "co"+                               , "col"+                               , "comm"+                               , "cp"+                               , "cpio"+                               , "cpp"+                               , "cut"+                               , "date"+                               , "dc"+                               , "dcop"+                               , "dd"+                               , "deallocvt"+                               , "df"+                               , "diff"+                               , "diff3"+                               , "dir"+                               , "dircolors"+                               , "directomatic"+                               , "dirname"+                               , "dmesg"+                               , "dnsdomainname"+                               , "domainname"+                               , "du"+                               , "dumpkeys"+                               , "echo"+                               , "ed"+                               , "egrep"+                               , "env"+                               , "expr"+                               , "false"+                               , "fbset"+                               , "fgconsole"+                               , "fgrep"+                               , "file"+                               , "find"+                               , "flex"+                               , "flex++"+                               , "fmt"+                               , "free"+                               , "ftp"+                               , "funzip"+                               , "fuser"+                               , "g++"+                               , "gawk"+                               , "gc"+                               , "gcc"+                               , "gdb"+                               , "getent"+                               , "getkeycodes"+                               , "getopt"+                               , "gettext"+                               , "gettextize"+                               , "gimp"+                               , "gimp-remote"+                               , "gimptool"+                               , "git"+                               , "gmake"+                               , "gocr"+                               , "grep"+                               , "groff"+                               , "groups"+                               , "gs"+                               , "gunzip"+                               , "gzexe"+                               , "gzip"+                               , "head"+                               , "hexdump"+                               , "hostname"+                               , "id"+                               , "igawk"+                               , "install"+                               , "join"+                               , "kbd_mode"+                               , "kbdrate"+                               , "kdialog"+                               , "kfile"+                               , "kill"+                               , "killall"+                               , "last"+                               , "lastb"+                               , "ld"+                               , "ld86"+                               , "ldd"+                               , "less"+                               , "lex"+                               , "link"+                               , "ln"+                               , "loadkeys"+                               , "loadunimap"+                               , "locate"+                               , "lockfile"+                               , "login"+                               , "logname"+                               , "lp"+                               , "lpr"+                               , "ls"+                               , "lsattr"+                               , "lsmod"+                               , "lsmod.old"+                               , "lynx"+                               , "lzcat"+                               , "lzcmp"+                               , "lzdiff"+                               , "lzegrep"+                               , "lzfgrep"+                               , "lzgrep"+                               , "lzless"+                               , "lzma"+                               , "lzmainfo"+                               , "lzmore"+                               , "m4"+                               , "make"+                               , "man"+                               , "mapscrn"+                               , "mesg"+                               , "mkdir"+                               , "mkfifo"+                               , "mknod"+                               , "mktemp"+                               , "more"+                               , "mount"+                               , "msgfmt"+                               , "mv"+                               , "namei"+                               , "nano"+                               , "nasm"+                               , "nawk"+                               , "netstat"+                               , "nice"+                               , "nisdomainname"+                               , "nl"+                               , "nm"+                               , "nm86"+                               , "nmap"+                               , "nohup"+                               , "nop"+                               , "nroff"+                               , "od"+                               , "openvt"+                               , "passwd"+                               , "patch"+                               , "pcregrep"+                               , "pcretest"+                               , "perl"+                               , "perror"+                               , "pgawk"+                               , "pidof"+                               , "ping"+                               , "pr"+                               , "printf"+                               , "procmail"+                               , "prune"+                               , "ps"+                               , "ps2ascii"+                               , "ps2epsi"+                               , "ps2frag"+                               , "ps2pdf"+                               , "ps2ps"+                               , "psbook"+                               , "psmerge"+                               , "psnup"+                               , "psresize"+                               , "psselect"+                               , "pstops"+                               , "pstree"+                               , "pwd"+                               , "qmake"+                               , "rbash"+                               , "rcs"+                               , "readlink"+                               , "red"+                               , "resizecons"+                               , "rev"+                               , "rm"+                               , "rmdir"+                               , "rsync"+                               , "run-parts"+                               , "sash"+                               , "scp"+                               , "sed"+                               , "seq"+                               , "setfont"+                               , "setkeycodes"+                               , "setleds"+                               , "setmetamode"+                               , "setserial"+                               , "setterm"+                               , "sh"+                               , "showkey"+                               , "shred"+                               , "size"+                               , "size86"+                               , "skill"+                               , "sleep"+                               , "slogin"+                               , "snice"+                               , "sort"+                               , "sox"+                               , "split"+                               , "ssed"+                               , "ssh"+                               , "ssh-add"+                               , "ssh-agent"+                               , "ssh-keygen"+                               , "ssh-keyscan"+                               , "stat"+                               , "strings"+                               , "strip"+                               , "stty"+                               , "su"+                               , "sudo"+                               , "suidperl"+                               , "sum"+                               , "svn"+                               , "sync"+                               , "tac"+                               , "tail"+                               , "tar"+                               , "tee"+                               , "tempfile"+                               , "test"+                               , "touch"+                               , "tr"+                               , "troff"+                               , "true"+                               , "umount"+                               , "uname"+                               , "unicode_start"+                               , "unicode_stop"+                               , "uniq"+                               , "unlink"+                               , "unlzma"+                               , "unxz"+                               , "unzip"+                               , "updatedb"+                               , "updmap"+                               , "uptime"+                               , "users"+                               , "utmpdump"+                               , "uuidgen"+                               , "valgrind"+                               , "vdir"+                               , "vmstat"+                               , "w"+                               , "wall"+                               , "wc"+                               , "wget"+                               , "whatis"+                               , "whereis"+                               , "which"+                               , "who"+                               , "whoami"+                               , "write"+                               , "xargs"+                               , "xdg-open"+                               , "xhost"+                               , "xmodmap"+                               , "xset"+                               , "xz"+                               , "xzcat"+                               , "yacc"+                               , "yes"+                               , "ypdomainname"+                               , "zcat"+                               , "zcmp"+                               , "zdiff"+                               , "zegrep"+                               , "zfgrep"+                               , "zforce"+                               , "zgrep"+                               , "zip"+                               , "zless"+                               , "zmore"+                               , "znew"+                               , "zsh"+                               , "zsoelim"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "CommandArgsBackq" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([\\w_@.%*?+-]|\\\\ )*(?=/)"+                              , reCompiled =+                                  Just (compileRegex True "([\\w_@.%*?+-]|\\\\ )*(?=/)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "~\\w*"+                              , reCompiled = Just (compileRegex True "~\\w*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/([\\w_@.%*?+-]|\\\\ )*(?=([/);$`'\"]|$))"+                              , reCompiled =+                                  Just+                                    (compileRegex True "/([\\w_@.%*?+-]|\\\\ )*(?=([/);$`'\"]|$))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/([\\w_@.%*?+-]|\\\\ )*(?=([\\s);$`'\"]|$))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "/([\\w_@.%*?+-]|\\\\ )*(?=([\\s);$`'\"]|$))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "CommandArgsBackq" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([\\w_@.%*?+-]|\\\\ )*"+                              , reCompiled = Just (compileRegex True "([\\w_@.%*?+-]|\\\\ )*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "CommandArgsBackq" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindOthers"+          , Context+              { cName = "FindOthers"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[][;\\\\$`{}()|&<>* ]"+                              , reCompiled = Just (compileRegex True "\\\\[][;\\\\$`{}()|&<>* ]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\$"+                              , reCompiled = Just (compileRegex True "\\\\$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{(?!(\\s|$))\\S*\\}"+                              , reCompiled = Just (compileRegex True "\\{(?!(\\s|$))\\S*\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([\\w_@.%*?+-]|\\\\ )*(?=/)"+                              , reCompiled =+                                  Just (compileRegex True "([\\w_@.%*?+-]|\\\\ )*(?=/)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "~\\w*"+                              , reCompiled = Just (compileRegex True "~\\w*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/([\\w_@.%*?+-]|\\\\ )*(?=([\\s/):;$`'\"]|$))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "/([\\w_@.%*?+-]|\\\\ )*(?=([\\s/):;$`'\"]|$))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindSpecialCommands"+          , Context+              { cName = "FindSpecialCommands"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '(' '('+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "ExprDblParen" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[\\[(?=($|\\s))"+                              , reCompiled = Just (compileRegex True "\\[\\[(?=($|\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Bash" , "ExprDblBracket" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s\\[\\[(?=($|\\s))"+                              , reCompiled = Just (compileRegex True "\\s\\[\\[(?=($|\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "ExprDblBracket" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[(?=($|\\s))"+                              , reCompiled = Just (compileRegex True "\\[(?=($|\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Bash" , "ExprBracket" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s\\[(?=($|\\s))"+                              , reCompiled = Just (compileRegex True "\\s\\[(?=($|\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "ExprBracket" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{(?=($|\\s))"+                              , reCompiled = Just (compileRegex True "\\{(?=($|\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "Group" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "SubShell" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bdo(?![\\w$+-])"+                              , reCompiled = Just (compileRegex True "\\bdo(?![\\w$+-])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bdone(?![\\w$+-])"+                              , reCompiled = Just (compileRegex True "\\bdone(?![\\w$+-])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bif(?=($|\\s))"+                              , reCompiled = Just (compileRegex True "\\bif(?=($|\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bfi(?![\\w$+-])"+                              , reCompiled = Just (compileRegex True "\\bfi(?![\\w$+-])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bcase(?![\\w$+-])"+                              , reCompiled = Just (compileRegex True "\\bcase(?![\\w$+-])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "Case" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[A-Za-z_][A-Za-z0-9_]*\\+?="+                              , reCompiled =+                                  Just (compileRegex True "\\b[A-Za-z_][A-Za-z0-9_]*\\+?=")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "Assign" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[A-Za-z_][A-Za-z0-9_]*(?=\\[.+\\]\\+?=)"+                              , reCompiled =+                                  Just+                                    (compileRegex True "\\b[A-Za-z_][A-Za-z0-9_]*(?=\\[.+\\]\\+?=)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "AssignSubscr" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect ":()"+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bfunction\\b"+                              , reCompiled = Just (compileRegex True "\\bfunction\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "FunctionDef" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Za-z_:][A-Za-z0-9_:#%@-]*\\s*\\(\\)"+                              , reCompiled =+                                  Just (compileRegex True "[A-Za-z_:][A-Za-z0-9_:#%@-]*\\s*\\(\\)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,;<=>?\\`|~"+                              }+                            (makeWordSet+                               True+                               [ "elif"+                               , "else"+                               , "for"+                               , "function"+                               , "in"+                               , "select"+                               , "set"+                               , "then"+                               , "until"+                               , "while"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.(?=\\s)"+                              , reCompiled = Just (compileRegex True "\\.(?=\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,;<=>?\\`|~"+                              }+                            (makeWordSet+                               True+                               [ "declare"+                               , "export"+                               , "local"+                               , "read"+                               , "readonly"+                               , "typeset"+                               , "unset"+                               ])+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "VarName" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\d*<<<"+                              , reCompiled = Just (compileRegex True "\\d*<<<")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<<"+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "HereDoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[<>]\\("+                              , reCompiled = Just (compileRegex True "[<>]\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "ProcessSubst" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([0-9]*(>{1,2}|<)(&[0-9]+-?)?|&>|>&|[0-9]*<>)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "([0-9]*(>{1,2}|<)(&[0-9]+-?)?|&>|>&|[0-9]*<>)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([|&])\\1?"+                              , reCompiled = Just (compileRegex True "([|&])\\1?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindStrings"+          , Context+              { cName = "FindStrings"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '\''+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '"'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "StringSQ" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "StringDQ" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "StringEsc" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "StringDQ" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindSubstitutions"+          , Context+              { cName = "FindSubstitutions"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[A-Za-z_][A-Za-z0-9_]*\\["+                              , reCompiled =+                                  Just (compileRegex True "\\$[A-Za-z_][A-Za-z0-9_]*\\[")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "Subscript" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[A-Za-z_][A-Za-z0-9_]*"+                              , reCompiled = Just (compileRegex True "\\$[A-Za-z_][A-Za-z0-9_]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[*@#?$!_0-9-]"+                              , reCompiled = Just (compileRegex True "\\$[*@#?$!_0-9-]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\{[*@#?$!_0-9-]\\}"+                              , reCompiled = Just (compileRegex True "\\$\\{[*@#?$!_0-9-]\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\{#[A-Za-z_][A-Za-z0-9_]*(\\[[*@]\\])?\\}"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\$\\{#[A-Za-z_][A-Za-z0-9_]*(\\[[*@]\\])?\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\{![A-Za-z_][A-Za-z0-9_]*(\\[[*@]\\]|[*@])?\\}"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\$\\{![A-Za-z_][A-Za-z0-9_]*(\\[[*@]\\]|[*@])?\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\{#[0-9]+\\}"+                              , reCompiled = Just (compileRegex True "\\$\\{#[0-9]+\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\{[A-Za-z_][A-Za-z0-9_]*"+                              , reCompiled =+                                  Just (compileRegex True "\\$\\{[A-Za-z_][A-Za-z0-9_]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "VarBrace" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\{[*@#?$!_0-9-](?=[:#%/=?+-])"+                              , reCompiled =+                                  Just (compileRegex True "\\$\\{[*@#?$!_0-9-](?=[:#%/=?+-])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "VarBrace" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "$(("+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "ExprDblParenSubst" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "$(<"+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "SubstFile" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "$("+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "SubstCommand" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "SubstBackq" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[`$\\\\]"+                              , reCompiled = Just (compileRegex True "\\\\[`$\\\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindTests"+          , Context+              { cName = "FindTests"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-[abcdefghkprstuwxOGLSNozn](?=\\s)"+                              , reCompiled =+                                  Just (compileRegex True "-[abcdefghkprstuwxOGLSNozn](?=\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-([no]t|ef)(?=\\s)"+                              , reCompiled = Just (compileRegex True "-([no]t|ef)(?=\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([!=]=?|[><])(?=\\s)"+                              , reCompiled = Just (compileRegex True "([!=]=?|[><])(?=\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-(eq|ne|[gl][te])(?=\\s)"+                              , reCompiled = Just (compileRegex True "-(eq|ne|[gl][te])(?=\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FunctionDef"+          , Context+              { cName = "FunctionDef"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+[A-Za-z_:][A-Za-z0-9_:#%@-]*(\\s*\\(\\))?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\s+[A-Za-z_:][A-Za-z0-9_:#%@-]*(\\s*\\(\\))?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "Group"+          , Context+              { cName = "Group"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindAll" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "HereDoc"+          , Context+              { cName = "HereDoc"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<-\\s*\"([^|&;()<>\\s]+)\")"+                              , reCompiled =+                                  Just (compileRegex True "(<<-\\s*\"([^|&;()<>\\s]+)\")")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "HereDocIQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<-\\s*'([^|&;()<>\\s]+)')"+                              , reCompiled =+                                  Just (compileRegex True "(<<-\\s*'([^|&;()<>\\s]+)')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "HereDocIQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<-\\s*\\\\([^|&;()<>\\s]+))"+                              , reCompiled =+                                  Just (compileRegex True "(<<-\\s*\\\\([^|&;()<>\\s]+))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "HereDocIQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<-\\s*([^|&;()<>\\s]+))"+                              , reCompiled = Just (compileRegex True "(<<-\\s*([^|&;()<>\\s]+))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "HereDocINQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<\\s*\"([^|&;()<>\\s]+)\")"+                              , reCompiled =+                                  Just (compileRegex True "(<<\\s*\"([^|&;()<>\\s]+)\")")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "HereDocQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<\\s*'([^|&;()<>\\s]+)')"+                              , reCompiled =+                                  Just (compileRegex True "(<<\\s*'([^|&;()<>\\s]+)')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "HereDocQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<\\s*\\\\([^|&;()<>\\s]+))"+                              , reCompiled =+                                  Just (compileRegex True "(<<\\s*\\\\([^|&;()<>\\s]+))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "HereDocQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<\\s*([^|&;()<>\\s]+))"+                              , reCompiled = Just (compileRegex True "(<<\\s*([^|&;()<>\\s]+))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "HereDocNQ" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<<"+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "HereDocINQ"+          , Context+              { cName = "HereDocINQ"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1" , reCompiled = Nothing , reCaseSensitive = True }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "HereDocRemainder" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\t*%2\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "HereDocIQ"+          , Context+              { cName = "HereDocIQ"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1" , reCompiled = Nothing , reCaseSensitive = True }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "HereDocRemainder" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\t*%2\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "HereDocNQ"+          , Context+              { cName = "HereDocNQ"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1" , reCompiled = Nothing , reCaseSensitive = True }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "HereDocRemainder" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%2\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "HereDocQ"+          , Context+              { cName = "HereDocQ"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1" , reCompiled = Nothing , reCaseSensitive = True }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "HereDocRemainder" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%2\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "HereDocRemainder"+          , Context+              { cName = "HereDocRemainder"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindAll" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ProcessSubst"+          , Context+              { cName = "ProcessSubst"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindCommentsParen" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindCommands" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Start"+          , Context+              { cName = "Start"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindAll" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "StringDQ"+          , Context+              { cName = "StringDQ"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[`\"\\\\$\\n]"+                              , reCompiled = Just (compileRegex True "\\\\[`\"\\\\$\\n]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindSubstitutions" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "StringEsc"+          , Context+              { cName = "StringEsc"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[abefnrtv\\\\']"+                              , reCompiled = Just (compileRegex True "\\\\[abefnrtv\\\\']")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\([0-7]{1,3}|x[A-Fa-f0-9]{1,2}|c.)"+                              , reCompiled =+                                  Just (compileRegex True "\\\\([0-7]{1,3}|x[A-Fa-f0-9]{1,2}|c.)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "StringSQ"+          , Context+              { cName = "StringSQ"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SubShell"+          , Context+              { cName = "SubShell"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindAll" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Subscript"+          , Context+              { cName = "Subscript"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindStrings" )+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindSubstitutions" )+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindOthers" )+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = VariableTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SubstBackq"+          , Context+              { cName = "SubstBackq"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindCommentsBackq" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindCommandsBackq" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SubstCommand"+          , Context+              { cName = "SubstCommand"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindCommentsParen" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindCommands" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SubstFile"+          , Context+              { cName = "SubstFile"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindCommentsParen" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "VarAlt"+          , Context+              { cName = "VarAlt"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "VarBrace"+          , Context+              { cName = "VarBrace"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "Subscript" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(:?[-=?+]|##?|%%?)"+                              , reCompiled = Just (compileRegex True "(:?[-=?+]|##?|%%?)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "VarAlt" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "//?"+                              , reCompiled = Just (compileRegex True "//?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "VarSubst" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "VarSub" ) ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "VarName"+          , Context+              { cName = "VarName"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-[A-Za-z0-9]+"+                              , reCompiled = Just (compileRegex True "-[A-Za-z0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "--[a-z][A-Za-z0-9_-]*"+                              , reCompiled = Just (compileRegex True "--[a-z][A-Za-z0-9_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[A-Za-z_][A-Za-z0-9_]*"+                              , reCompiled = Just (compileRegex True "\\b[A-Za-z_][A-Za-z0-9_]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "Subscript" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "Assign" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^]})|;`&><]"+                              , reCompiled = Just (compileRegex True "[^]})|;`&><]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "VarSub"+          , Context+              { cName = "VarSub"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "VarSub2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Za-z_][A-Za-z0-9_]*"+                              , reCompiled = Just (compileRegex True "[A-Za-z_][A-Za-z0-9_]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[0-9]+(?=[:}])"+                              , reCompiled = Just (compileRegex True "[0-9]+(?=[:}])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindSubstitutions" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "VarSub2"+          , Context+              { cName = "VarSub2"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Za-z_][A-Za-z0-9_]*"+                              , reCompiled = Just (compileRegex True "[A-Za-z_][A-Za-z0-9_]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[0-9](?=[:}])"+                              , reCompiled = Just (compileRegex True "[0-9](?=[:}])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindSubstitutions" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "VarSubst"+          , Context+              { cName = "VarSubst"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '/'+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Bash" , "VarSubst2" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "VarSubst2"+          , Context+              { cName = "VarSubst2"+              , cSyntax = "Bash"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Bash" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Wilbert Berendsen (wilbert@kde.nl)"+  , sVersion = "3"+  , sLicense = "LGPL"+  , sExtensions =+      [ "*.sh"+      , "*.bash"+      , "*.ebuild"+      , "*.eclass"+      , "*.nix"+      , ".bashrc"+      , ".bash_profile"+      , ".bash_login"+      , ".profile"+      ]+  , sStartingContext = "Start"+  }
+ src/Skylighting/Syntax/Bibtex.hs view
@@ -0,0 +1,576 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Bibtex (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "BibTeX"+  , sFilename = "bibtex.xml"+  , sShortname = "Bibtex"+  , sContexts =+      fromList+        [ ( "CurlyBracket"+          , Context+              { cName = "CurlyBracket"+              , cSyntax = "BibTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "BibTeX" , "CurlyBracket" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\([a-zA-Z@]+|[^ ])"+                              , reCompiled = Just (compileRegex True "\\\\([a-zA-Z@]+|[^ ])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "}$"+                              , reCompiled = Just (compileRegex True "}$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Entry"+          , Context+              { cName = "Entry"+              , cSyntax = "BibTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z0-9_@\\\\-\\\\:]+"+                              , reCompiled = Just (compileRegex True "[a-zA-Z0-9_@\\\\-\\\\:]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "BibTeX" , "Field" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Field"+          , Context+              { cName = "Field"+              , cSyntax = "BibTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z0-9\\-_\\.]+"+                              , reCompiled = Just (compileRegex True "[a-zA-Z0-9\\-_\\.]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "BibTeX" , "CurlyBracket" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "BibTeX" , "QuotedText" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[0-9]+"+                              , reCompiled = Just (compileRegex True "[0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z0-9\\-]+"+                              , reCompiled = Just (compileRegex True "[a-zA-Z0-9\\-]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "BibTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "@article"+                               , "@book"+                               , "@booklet"+                               , "@collection"+                               , "@company"+                               , "@conference"+                               , "@electronic"+                               , "@inbook"+                               , "@incollection"+                               , "@inproceedings"+                               , "@manual"+                               , "@mastersthesis"+                               , "@misc"+                               , "@online"+                               , "@patent"+                               , "@periodical"+                               , "@person"+                               , "@phdthesis"+                               , "@place"+                               , "@proceedings"+                               , "@report"+                               , "@set"+                               , "@techreport"+                               , "@thesis"+                               , "@unpublished"+                               , "@www"+                               ])+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "BibTeX" , "Entry" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "@string"+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "BibTeX" , "StringCommand" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "@preamble"+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "BibTeX" , "PreambleCommand" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "@comment"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "PreambleCommand"+          , Context+              { cName = "PreambleCommand"+              , cSyntax = "BibTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "BibTeX" , "CurlyBracket" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "QuotedText"+          , Context+              { cName = "QuotedText"+              , cSyntax = "BibTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\([a-zA-Z@]+|[^ ])"+                              , reCompiled = Just (compileRegex True "\\\\([a-zA-Z@]+|[^ ])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "StringCommand"+          , Context+              { cName = "StringCommand"+              , cSyntax = "BibTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "BibTeX" , "CurlyBracket" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z0-9\\-]+"+                              , reCompiled = Just (compileRegex True "[a-zA-Z0-9\\-]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "BibTeX" , "CurlyBracket" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        ]+  , sAuthor =+      "Jeroen Wijnhout (Jeroen.Wijnhout@kdemail.net)+Thomas Braun (thomas.braun@virtuell-zuhause.de)"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions = [ "*.bib" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Boo.hs view
@@ -0,0 +1,1562 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Boo (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Boo"+  , sFilename = "boo.xml"+  , sShortname = "Boo"+  , sContexts =+      fromList+        [ ( "Comment SlashSlash"+          , Context+              { cName = "Comment SlashSlash"+              , cSyntax = "Boo"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Boo"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "as" , "from" , "import" , "namespace" ])+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "abstract"+                               , "callable"+                               , "class"+                               , "constructor"+                               , "def"+                               , "destructor"+                               , "do"+                               , "enum"+                               , "event"+                               , "final"+                               , "get"+                               , "interface"+                               , "internal"+                               , "macro"+                               , "of"+                               , "override"+                               , "partial"+                               , "private"+                               , "protected"+                               , "public"+                               , "return"+                               , "set"+                               , "static"+                               , "struct"+                               , "transient"+                               , "virtual"+                               , "yield"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True [ "and" , "assert" , "in" , "is" , "not" , "or" ])+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "and"+                               , "break"+                               , "cast"+                               , "continue"+                               , "elif"+                               , "else"+                               , "ensure"+                               , "except"+                               , "for"+                               , "given"+                               , "goto"+                               , "if"+                               , "in"+                               , "is"+                               , "isa"+                               , "not"+                               , "or"+                               , "otherwise"+                               , "pass"+                               , "raise"+                               , "ref"+                               , "try"+                               , "unless"+                               , "when"+                               , "while"+                               ])+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "__eval__"+                               , "__switch__"+                               , "array"+                               , "assert"+                               , "checked"+                               , "enumerate"+                               , "filter"+                               , "getter"+                               , "len"+                               , "lock"+                               , "map"+                               , "matrix"+                               , "max"+                               , "min"+                               , "normalArrayIndexing"+                               , "print"+                               , "property"+                               , "range"+                               , "rawArrayIndexing"+                               , "required"+                               , "typeof"+                               , "unchecked"+                               , "using"+                               , "yieldAll"+                               , "zip"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "null" , "self" , "super" ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "false" , "true" ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "bool"+                               , "byte"+                               , "char"+                               , "date"+                               , "decimal"+                               , "double"+                               , "duck"+                               , "int"+                               , "long"+                               , "object"+                               , "regex"+                               , "sbyte"+                               , "short"+                               , "single"+                               , "string"+                               , "timespan"+                               , "uint"+                               , "ulong"+                               , "ushort"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z_][a-zA-Z_0-9]+"+                              , reCompiled = Just (compileRegex True "[a-zA-Z_][a-zA-Z_0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  " ((([0-9]*\\.[0-9]+|[0-9]+\\.)|([0-9]+|([0-9]*\\.[0-9]+|[0-9]+\\.))[eE](\\+|-)?[0-9]+)|[0-9]+)[jJ]"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       " ((([0-9]*\\.[0-9]+|[0-9]+\\.)|([0-9]+|([0-9]*\\.[0-9]+|[0-9]+\\.))[eE](\\+|-)?[0-9]+)|[0-9]+)[jJ]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([0-9]+\\.[0-9]*|\\.[0-9]+)([eE][0-9]+)?"+                              , reCompiled =+                                  Just+                                    (compileRegex True "([0-9]+\\.[0-9]*|\\.[0-9]+)([eE][0-9]+)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([1-9][0-9]*([eE][0-9]+)?|0)"+                              , reCompiled =+                                  Just (compileRegex True "([1-9][0-9]*([eE][0-9]+)?|0)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[1-9][0-9]*([eE][0-9.]+)?[Ll]"+                              , reCompiled =+                                  Just (compileRegex True "[1-9][0-9]*([eE][0-9.]+)?[Ll]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "0[Xx][0-9a-fA-F]+"+                              , reCompiled = Just (compileRegex True "0[Xx][0-9a-fA-F]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "0[1-9][0-9]*"+                              , reCompiled = Just (compileRegex True "0[1-9][0-9]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[rR]'''"+                              , reCompiled = Just (compileRegex True "[rR]'''")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Boo" , "Raw Tripple A-string" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[rR]\"\"\""+                              , reCompiled = Just (compileRegex True "[rR]\"\"\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Boo" , "Raw Tripple Q-string" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[rR]'"+                              , reCompiled = Just (compileRegex True "[rR]'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Boo" , "Raw A-string" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[rR]\""+                              , reCompiled = Just (compileRegex True "[rR]\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Boo" , "Raw Q-string" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#.*$"+                              , reCompiled = Just (compileRegex True "#.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*u?'''"+                              , reCompiled = Just (compileRegex True "\\s*u?'''")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Boo" , "Tripple A-comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*u?\"\"\""+                              , reCompiled = Just (compileRegex True "\\s*u?\"\"\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Boo" , "Tripple Q-comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Boo" , "Comment SlashSlash" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "'''"+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Boo" , "Tripple A-string" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "\"\"\""+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Boo" , "Tripple Q-string" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Boo" , "Single A-string" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Boo" , "Single Q-string" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Boo" , "parenthesised" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "[|"+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Boo" , "Quasi-Quotation" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "|]"+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[+*/%\\|=;\\!<>!^&~-]"+                              , reCompiled = Just (compileRegex True "[+*/%\\|=;\\!<>!^&~-]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%[a-zA-Z]"+                              , reCompiled = Just (compileRegex True "%[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Quasi-Quotation"+          , Context+              { cName = "Quasi-Quotation"+              , cSyntax = "Boo"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Boo" , "Normal" )+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OperatorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Raw A-string"+          , Context+              { cName = "Raw A-string"+              , cSyntax = "Boo"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%\\([a-zA-Z0-9_]+\\)[a-zA-Z]"+                              , reCompiled =+                                  Just (compileRegex True "%\\([a-zA-Z0-9_]+\\)[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%[a-zA-Z]"+                              , reCompiled = Just (compileRegex True "%[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = VerbatimStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Raw Q-string"+          , Context+              { cName = "Raw Q-string"+              , cSyntax = "Boo"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%\\([a-zA-Z0-9_]+\\)[a-zA-Z]"+                              , reCompiled =+                                  Just (compileRegex True "%\\([a-zA-Z0-9_]+\\)[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%[a-zA-Z]"+                              , reCompiled = Just (compileRegex True "%[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = VerbatimStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Raw Tripple A-string"+          , Context+              { cName = "Raw Tripple A-string"+              , cSyntax = "Boo"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%\\([a-zA-Z0-9_]+\\)[a-zA-Z]"+                              , reCompiled =+                                  Just (compileRegex True "%\\([a-zA-Z0-9_]+\\)[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%[a-zA-Z]"+                              , reCompiled = Just (compileRegex True "%[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'''"+                              , reCompiled = Just (compileRegex True "'''")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = VerbatimStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Raw Tripple Q-string"+          , Context+              { cName = "Raw Tripple Q-string"+              , cSyntax = "Boo"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%\\([a-zA-Z0-9_]+\\)[a-zA-Z]"+                              , reCompiled =+                                  Just (compileRegex True "%\\([a-zA-Z0-9_]+\\)[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%[a-zA-Z]"+                              , reCompiled = Just (compileRegex True "%[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"\"\""+                              , reCompiled = Just (compileRegex True "\"\"\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = VerbatimStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Single A-comment"+          , Context+              { cName = "Single A-comment"+              , cSyntax = "Boo"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Single A-string"+          , Context+              { cName = "Single A-string"+              , cSyntax = "Boo"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%\\([a-zA-Z0-9_]+\\)[a-zA-Z]"+                              , reCompiled =+                                  Just (compileRegex True "%\\([a-zA-Z0-9_]+\\)[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%[a-zA-Z]"+                              , reCompiled = Just (compileRegex True "%[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Single Q-comment"+          , Context+              { cName = "Single Q-comment"+              , cSyntax = "Boo"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Single Q-string"+          , Context+              { cName = "Single Q-string"+              , cSyntax = "Boo"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%\\([a-zA-Z0-9_]+\\)[a-zA-Z]"+                              , reCompiled =+                                  Just (compileRegex True "%\\([a-zA-Z0-9_]+\\)[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%[a-zA-Z]"+                              , reCompiled = Just (compileRegex True "%[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Tripple A-comment"+          , Context+              { cName = "Tripple A-comment"+              , cSyntax = "Boo"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "'''"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Tripple A-string"+          , Context+              { cName = "Tripple A-string"+              , cSyntax = "Boo"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%\\([a-zA-Z0-9_]+\\)[a-zA-Z]"+                              , reCompiled =+                                  Just (compileRegex True "%\\([a-zA-Z0-9_]+\\)[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%[a-zA-Z]"+                              , reCompiled = Just (compileRegex True "%[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'''"+                              , reCompiled = Just (compileRegex True "'''")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Tripple Q-comment"+          , Context+              { cName = "Tripple Q-comment"+              , cSyntax = "Boo"+              , cRules =+                  [ Rule+                      { rMatcher = HlCChar+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"\"\""+                              , reCompiled = Just (compileRegex True "\"\"\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Tripple Q-string"+          , Context+              { cName = "Tripple Q-string"+              , cSyntax = "Boo"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%\\([a-zA-Z0-9_]+\\)[a-zA-Z]"+                              , reCompiled =+                                  Just (compileRegex True "%\\([a-zA-Z0-9_]+\\)[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%[a-zA-Z]"+                              , reCompiled = Just (compileRegex True "%[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"\"\""+                              , reCompiled = Just (compileRegex True "\"\"\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "parenthesised"+          , Context+              { cName = "parenthesised"+              , cSyntax = "Boo"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Boo" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Marc Dassonneville"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions = [ "*.boo" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/C.hs view
@@ -0,0 +1,1299 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.C (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "C"+  , sFilename = "c.xml"+  , sShortname = "C"+  , sContexts =+      fromList+        [ ( "AfterHash"+          , Context+              { cName = "AfterHash"+              , cSyntax = "C"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*(?:include|include_next)"+                              , reCompiled =+                                  Just (compileRegex False "#\\s*(?:include|include_next)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "Include" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*if(?:def|ndef)?(?=\\s+\\S)"+                              , reCompiled =+                                  Just (compileRegex False "#\\s*if(?:def|ndef)?(?=\\s+\\S)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*endif"+                              , reCompiled = Just (compileRegex False "#\\s*endif")+                              , reCaseSensitive = False+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*define.*((?=\\\\))"+                              , reCompiled = Just (compileRegex False "#\\s*define.*((?=\\\\))")+                              , reCaseSensitive = False+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "Define" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*pragma\\s+mark\\s+-\\s*$"+                              , reCompiled =+                                  Just (compileRegex False "#\\s*pragma\\s+mark\\s+-\\s*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*pragma\\s+mark"+                              , reCompiled = Just (compileRegex False "#\\s*pragma\\s+mark")+                              , reCaseSensitive = False+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "#\\s*(?:el(?:se|if)|define|undef|line|error|warning|pragma)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "#\\s*(?:el(?:se|if)|define|undef|line|error|warning|pragma)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s+[0-9]+"+                              , reCompiled = Just (compileRegex False "#\\s+[0-9]+")+                              , reCaseSensitive = False+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "Preprocessor" ) ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Commentar 1"+          , Context+              { cName = "Commentar 1"+              , cSyntax = "C"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Commentar 2"+          , Context+              { cName = "Commentar 2"+              , cSyntax = "C"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Commentar/Preprocessor"+          , Context+              { cName = "Commentar/Preprocessor"+              , cSyntax = "C"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Define"+          , Context+              { cName = "Define"+              , cSyntax = "C"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = PreprocessorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Include"+          , Context+              { cName = "Include"+              , cSyntax = "C"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = RangeDetect '"' '"'+                      , rAttribute = ImportTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = RangeDetect '<' '>'+                      , rAttribute = ImportTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "C" , "Preprocessor" )+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = PreprocessorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "C"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*if\\s+0\\s*$"+                              , reCompiled = Just (compileRegex True "#\\s*if\\s+0\\s*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "Outscoped" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "AfterHash" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "//BEGIN"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "Region Marker" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "//END"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "Region Marker" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "break"+                               , "case"+                               , "continue"+                               , "default"+                               , "do"+                               , "else"+                               , "for"+                               , "goto"+                               , "if"+                               , "return"+                               , "switch"+                               , "while"+                               ])+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "enum"+                               , "extern"+                               , "inline"+                               , "sizeof"+                               , "struct"+                               , "typedef"+                               , "union"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "_Bool"+                               , "_Complex"+                               , "_Imaginary"+                               , "auto"+                               , "char"+                               , "const"+                               , "double"+                               , "float"+                               , "int"+                               , "int16_t"+                               , "int32_t"+                               , "int64_t"+                               , "int8_t"+                               , "int_fast16_t"+                               , "int_fast32_t"+                               , "int_fast64_t"+                               , "int_fast8_t"+                               , "int_least16_t"+                               , "int_least32_t"+                               , "int_least64_t"+                               , "int_least8_t"+                               , "intmax_t"+                               , "intptr_t"+                               , "long"+                               , "ptrdiff_t"+                               , "register"+                               , "restrict"+                               , "short"+                               , "sig_atomic_t"+                               , "signed"+                               , "size_t"+                               , "ssize_t"+                               , "static"+                               , "uint16_t"+                               , "uint32_t"+                               , "uint64_t"+                               , "uint8_t"+                               , "uint_fast16_t"+                               , "uint_fast32_t"+                               , "uint_fast64_t"+                               , "uint_fast8_t"+                               , "uint_least16_t"+                               , "uint_least32_t"+                               , "uint_least64_t"+                               , "uint_least8_t"+                               , "uintmax_t"+                               , "uintptr_t"+                               , "unsigned"+                               , "void"+                               , "volatile"+                               , "wchar_t"+                               , "wint_t"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren =+                          [ Rule+                              { rMatcher = AnyChar "fF"+                              , rAttribute = FloatTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = True+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "0b[01]+[ul]{0,3}"+                              , reCompiled = Just (compileRegex False "0b[01]+[ul]{0,3}")+                              , reCaseSensitive = False+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren =+                          [ Rule+                              { rMatcher = StringDetect "ULL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LUL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LLU"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "UL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LU"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "U"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "L"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "Commentar 1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "Commentar 2" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar ":!%&()+,-/.*<=>?[]|~^;"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Outscoped"+          , Context+              { cName = "Outscoped"+              , cSyntax = "C"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "Commentar 1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "Commentar 2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*if"+                              , reCompiled = Just (compileRegex True "#\\s*if")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "Outscoped intern" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*el(?:se|if)"+                              , reCompiled = Just (compileRegex True "#\\s*el(?:se|if)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*endif"+                              , reCompiled = Just (compileRegex True "#\\s*endif")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Outscoped intern"+          , Context+              { cName = "Outscoped intern"+              , cSyntax = "C"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "Commentar 1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "Commentar 2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*if"+                              , reCompiled = Just (compileRegex True "#\\s*if")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "Outscoped intern" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*endif"+                              , reCompiled = Just (compileRegex True "#\\s*endif")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Preprocessor"+          , Context+              { cName = "Preprocessor"+              , cSyntax = "C"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "" )+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "Commentar/Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C" , "Commentar 1" ) ]+                      }+                  ]+              , cAttribute = PreprocessorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Region Marker"+          , Context+              { cName = "Region Marker"+              , cSyntax = "C"+              , cRules = []+              , cAttribute = RegionMarkerTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "C"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = ""+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.c" , "*.C" , "*.h" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Changelog.hs view
@@ -0,0 +1,153 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Changelog (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex++syntax :: Syntax+syntax = Syntax+  { sName = "ChangeLog"+  , sFilename = "changelog.xml"+  , sShortname = "Changelog"+  , sContexts =+      fromList+        [ ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "ChangeLog"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '*'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ChangeLog" , "entry" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\d\\d\\d\\d\\s*-\\s*\\d\\d\\s*-\\s*\\d\\d\\s*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\d\\d\\d\\d\\s*-\\s*\\d\\d\\s*-\\s*\\d\\d\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "ChangeLog" , "line" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "entry"+          , Context+              { cName = "entry"+              , cSyntax = "ChangeLog"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ".*:"+                              , reCompiled = Just (compileRegex True ".*:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "line"+          , Context+              { cName = "line"+              , cSyntax = "ChangeLog"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\w\\s*)+"+                              , reCompiled = Just (compileRegex True "(\\w\\s*)+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<.*>\\s*$"+                              , reCompiled = Just (compileRegex True "<.*>\\s*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Dominik Haumann (dhdev@gmx.de)"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions = [ "ChangeLog" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Clojure.hs view
@@ -0,0 +1,1560 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Clojure (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Clojure"+  , sFilename = "clojure.xml"+  , sShortname = "Clojure"+  , sContexts =+      fromList+        [ ( "Default"+          , Context+              { cName = "Default"+              , cSyntax = "Clojure"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ";.*$"+                              , reCompiled = Just (compileRegex True ";.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '_'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[@~]\\S+"+                              , reCompiled = Just (compileRegex True "[@~]\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "::?[a-zA-Z0-9\\-]+"+                              , reCompiled = Just (compileRegex True "::?[a-zA-Z0-9\\-]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '^' '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '\''+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&(),.;[]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "*"+                               , "+"+                               , "-"+                               , "->"+                               , "->>"+                               , "."+                               , ".."+                               , "/"+                               , "<"+                               , "<="+                               , "="+                               , "=="+                               , ">"+                               , ">="+                               , "accessor"+                               , "aclone"+                               , "add-classpath"+                               , "add-watcher"+                               , "agent"+                               , "agent-errors"+                               , "aget"+                               , "alength"+                               , "alias"+                               , "all-ns"+                               , "alter"+                               , "alter-meta!"+                               , "alter-var-root"+                               , "amap"+                               , "ancestors"+                               , "and"+                               , "append-child"+                               , "apply"+                               , "apply-template"+                               , "are"+                               , "areduce"+                               , "array-map"+                               , "aset"+                               , "aset-boolean"+                               , "aset-byte"+                               , "aset-char"+                               , "aset-double"+                               , "aset-float"+                               , "aset-int"+                               , "aset-long"+                               , "aset-short"+                               , "assert"+                               , "assert-any"+                               , "assert-expr"+                               , "assert-predicate"+                               , "assoc"+                               , "assoc!"+                               , "assoc-in"+                               , "associative?"+                               , "atom"+                               , "atom?"+                               , "attrs"+                               , "await"+                               , "await-for"+                               , "await1"+                               , "bases"+                               , "bean"+                               , "bigdec"+                               , "bigint"+                               , "binding"+                               , "bit-and"+                               , "bit-and-not"+                               , "bit-clear"+                               , "bit-flip"+                               , "bit-not"+                               , "bit-or"+                               , "bit-set"+                               , "bit-shift-left"+                               , "bit-shift-right"+                               , "bit-test"+                               , "bit-xor"+                               , "boolean"+                               , "boolean-array"+                               , "booleans"+                               , "bound-fn"+                               , "bound-fn*"+                               , "branch?"+                               , "butlast"+                               , "byte"+                               , "byte-array"+                               , "bytes"+                               , "case"+                               , "cast"+                               , "catch"+                               , "char"+                               , "char-array"+                               , "char-escape-string"+                               , "char-name-string"+                               , "char?"+                               , "chars"+                               , "children"+                               , "chunk"+                               , "chunk-append"+                               , "chunk-buffer"+                               , "chunk-cons"+                               , "chunk-first"+                               , "chunk-next"+                               , "chunk-rest"+                               , "chunked-seq?"+                               , "class"+                               , "class?"+                               , "clear-agent-errors"+                               , "clojure-version"+                               , "coll?"+                               , "collection-tag"+                               , "comment"+                               , "commute"+                               , "comp"+                               , "comparator"+                               , "compare"+                               , "compare-and-set!"+                               , "compile"+                               , "complement"+                               , "compose-fixtures"+                               , "concat"+                               , "cond"+                               , "condp"+                               , "conj"+                               , "conj!"+                               , "cons"+                               , "constantly"+                               , "construct-proxy"+                               , "contains?"+                               , "content"+                               , "content-handler"+                               , "count"+                               , "counted?"+                               , "create-ns"+                               , "create-struct"+                               , "cycle"+                               , "dec"+                               , "decimal?"+                               , "declare"+                               , "delay"+                               , "delay?"+                               , "deliver"+                               , "deref"+                               , "derive"+                               , "descendants"+                               , "destructure"+                               , "difference"+                               , "disj"+                               , "disj!"+                               , "dissoc"+                               , "dissoc!"+                               , "distinct"+                               , "distinct?"+                               , "do"+                               , "do-template"+                               , "doall"+                               , "doc"+                               , "dorun"+                               , "doseq"+                               , "dosync"+                               , "dotimes"+                               , "doto"+                               , "double"+                               , "double-array"+                               , "doubles"+                               , "down"+                               , "drop"+                               , "drop-last"+                               , "drop-while"+                               , "e"+                               , "edit"+                               , "element"+                               , "emit"+                               , "emit-element"+                               , "empty"+                               , "empty?"+                               , "end?"+                               , "ensure"+                               , "enumeration-seq"+                               , "eval"+                               , "even?"+                               , "every?"+                               , "extend"+                               , "extend-protocol"+                               , "extend-type"+                               , "extenders"+                               , "extends?"+                               , "false?"+                               , "ffirst"+                               , "file-position"+                               , "file-seq"+                               , "filter"+                               , "finally"+                               , "find"+                               , "find-doc"+                               , "find-ns"+                               , "find-var"+                               , "first"+                               , "float"+                               , "float-array"+                               , "float?"+                               , "floats"+                               , "flush"+                               , "fn"+                               , "fn?"+                               , "fnext"+                               , "for"+                               , "force"+                               , "format"+                               , "function?"+                               , "future"+                               , "future-call"+                               , "future-cancel"+                               , "future-cancelled?"+                               , "future-done?"+                               , "future?"+                               , "gen-and-load-class"+                               , "gen-and-save-class"+                               , "gen-class"+                               , "gen-interface"+                               , "gensym"+                               , "get"+                               , "get-child"+                               , "get-child-count"+                               , "get-in"+                               , "get-method"+                               , "get-possibly-unbound-var"+                               , "get-proxy-class"+                               , "get-thread-bindings"+                               , "get-validator"+                               , "handle"+                               , "handler-case"+                               , "hash"+                               , "hash-map"+                               , "hash-set"+                               , "identical?"+                               , "identity"+                               , "if"+                               , "if-let"+                               , "if-not"+                               , "ifn?"+                               , "import"+                               , "in-ns"+                               , "inc"+                               , "inc-report-counter"+                               , "index"+                               , "init-proxy"+                               , "insert-child"+                               , "insert-left"+                               , "insert-right"+                               , "inspect"+                               , "inspect-table"+                               , "inspect-tree"+                               , "instance?"+                               , "int"+                               , "int-array"+                               , "integer?"+                               , "interleave"+                               , "intern"+                               , "interpose"+                               , "intersection"+                               , "into"+                               , "into-array"+                               , "ints"+                               , "io!"+                               , "is"+                               , "is-leaf"+                               , "isa?"+                               , "iterate"+                               , "iterator-seq"+                               , "join"+                               , "join-fixtures"+                               , "juxt"+                               , "key"+                               , "keys"+                               , "keyword"+                               , "keyword?"+                               , "keywordize-keys"+                               , "last"+                               , "lazy-cat"+                               , "lazy-seq"+                               , "left"+                               , "leftmost"+                               , "lefts"+                               , "let"+                               , "letfn"+                               , "line-seq"+                               , "list"+                               , "list*"+                               , "list-model"+                               , "list-provider"+                               , "list?"+                               , "load"+                               , "load-file"+                               , "load-reader"+                               , "load-script"+                               , "load-string"+                               , "loaded-libs"+                               , "locking"+                               , "long"+                               , "long-array"+                               , "longs"+                               , "loop"+                               , "macroexpand"+                               , "macroexpand-1"+                               , "macroexpand-all"+                               , "main"+                               , "make-array"+                               , "make-hierarchy"+                               , "make-node"+                               , "map"+                               , "map-invert"+                               , "map?"+                               , "mapcat"+                               , "max"+                               , "max-key"+                               , "memfn"+                               , "memoize"+                               , "merge"+                               , "merge-with"+                               , "meta"+                               , "method-sig"+                               , "methods"+                               , "min"+                               , "min-key"+                               , "mod"+                               , "name"+                               , "namespace"+                               , "neg?"+                               , "newline"+                               , "next"+                               , "nfirst"+                               , "nil?"+                               , "nnext"+                               , "node"+                               , "not"+                               , "not-any?"+                               , "not-empty"+                               , "not-every?"+                               , "not="+                               , "ns"+                               , "ns-aliases"+                               , "ns-imports"+                               , "ns-interns"+                               , "ns-map"+                               , "ns-name"+                               , "ns-publics"+                               , "ns-refers"+                               , "ns-resolve"+                               , "ns-unalias"+                               , "ns-unmap"+                               , "nth"+                               , "nthnext"+                               , "num"+                               , "number?"+                               , "odd?"+                               , "or"+                               , "parents"+                               , "partial"+                               , "partition"+                               , "path"+                               , "pcalls"+                               , "peek"+                               , "persistent!"+                               , "pmap"+                               , "pop"+                               , "pop!"+                               , "pop-thread-bindings"+                               , "pos?"+                               , "postwalk"+                               , "postwalk-demo"+                               , "postwalk-replace"+                               , "pr"+                               , "pr-str"+                               , "prefer-method"+                               , "prefers"+                               , "prev"+                               , "prewalk"+                               , "prewalk-demo"+                               , "prewalk-replace"+                               , "primitives-classnames"+                               , "print"+                               , "print-cause-trace"+                               , "print-ctor"+                               , "print-doc"+                               , "print-dup"+                               , "print-method"+                               , "print-namespace-doc"+                               , "print-simple"+                               , "print-special-doc"+                               , "print-stack-trace"+                               , "print-str"+                               , "print-throwable"+                               , "print-trace-element"+                               , "printf"+                               , "println"+                               , "println-str"+                               , "prn"+                               , "prn-str"+                               , "project"+                               , "promise"+                               , "proxy"+                               , "proxy-call-with-super"+                               , "proxy-mappings"+                               , "proxy-name"+                               , "proxy-super"+                               , "push-thread-bindings"+                               , "pvalues"+                               , "quot"+                               , "rand"+                               , "rand-int"+                               , "range"+                               , "ratio?"+                               , "rational?"+                               , "rationalize"+                               , "re-find"+                               , "re-groups"+                               , "re-matcher"+                               , "re-matches"+                               , "re-pattern"+                               , "re-seq"+                               , "read"+                               , "read-line"+                               , "read-string"+                               , "recur"+                               , "reduce"+                               , "ref"+                               , "ref-history-count"+                               , "ref-max-history"+                               , "ref-min-history"+                               , "ref-set"+                               , "refer"+                               , "refer-clojure"+                               , "reify"+                               , "release-pending-sends"+                               , "rem"+                               , "remove"+                               , "remove-method"+                               , "remove-ns"+                               , "remove-watcher"+                               , "rename"+                               , "rename-keys"+                               , "repeat"+                               , "repeatedly"+                               , "repl"+                               , "repl-caught"+                               , "repl-exception"+                               , "repl-prompt"+                               , "repl-read"+                               , "replace"+                               , "replicate"+                               , "report"+                               , "require"+                               , "reset!"+                               , "reset-meta!"+                               , "resolve"+                               , "rest"+                               , "resultset-seq"+                               , "reverse"+                               , "reversible?"+                               , "right"+                               , "rightmost"+                               , "rights"+                               , "root"+                               , "rseq"+                               , "rsubseq"+                               , "run-all-tests"+                               , "run-tests"+                               , "satisfies?"+                               , "second"+                               , "select"+                               , "select-keys"+                               , "send"+                               , "send-off"+                               , "seq"+                               , "seq-zip"+                               , "seq?"+                               , "seque"+                               , "sequence"+                               , "sequential?"+                               , "set"+                               , "set-test"+                               , "set-validator!"+                               , "set?"+                               , "short"+                               , "short-array"+                               , "shorts"+                               , "shutdown-agents"+                               , "skip-if-eol"+                               , "skip-whitespace"+                               , "slurp"+                               , "some"+                               , "sort"+                               , "sort-by"+                               , "sorted-map"+                               , "sorted-map-by"+                               , "sorted-set"+                               , "sorted-set-by"+                               , "sorted?"+                               , "special-form-anchor"+                               , "special-symbol?"+                               , "split-at"+                               , "split-with"+                               , "str"+                               , "stream?"+                               , "string?"+                               , "stringify-keys"+                               , "struct"+                               , "struct-map"+                               , "subs"+                               , "subseq"+                               , "subvec"+                               , "successful?"+                               , "supers"+                               , "swap!"+                               , "symbol"+                               , "symbol?"+                               , "sync"+                               , "syntax-symbol-anchor"+                               , "take"+                               , "take-last"+                               , "take-nth"+                               , "take-while"+                               , "test"+                               , "test-all-vars"+                               , "test-ns"+                               , "test-var"+                               , "testing"+                               , "testing-contexts-str"+                               , "testing-vars-str"+                               , "the-ns"+                               , "throw"+                               , "time"+                               , "to-array"+                               , "to-array-2d"+                               , "trampoline"+                               , "transient"+                               , "tree-seq"+                               , "true?"+                               , "try"+                               , "try-expr"+                               , "type"+                               , "unchecked-add"+                               , "unchecked-dec"+                               , "unchecked-divide"+                               , "unchecked-inc"+                               , "unchecked-multiply"+                               , "unchecked-negate"+                               , "unchecked-remainder"+                               , "unchecked-subtract"+                               , "underive"+                               , "unimport"+                               , "union"+                               , "unquote"+                               , "unquote-splicing"+                               , "up"+                               , "update-in"+                               , "update-proxy"+                               , "use"+                               , "use-fixtures"+                               , "val"+                               , "vals"+                               , "var-get"+                               , "var-set"+                               , "var?"+                               , "vary-meta"+                               , "vec"+                               , "vector"+                               , "vector?"+                               , "walk"+                               , "when"+                               , "when-first"+                               , "when-let"+                               , "when-not"+                               , "while"+                               , "with-bindings"+                               , "with-bindings*"+                               , "with-in-str"+                               , "with-loading-context"+                               , "with-local-vars"+                               , "with-meta"+                               , "with-open"+                               , "with-out-str"+                               , "with-precision"+                               , "with-test"+                               , "with-test-out"+                               , "xml-seq"+                               , "zero?"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&(),.;[]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "*1"+                               , "*2"+                               , "*3"+                               , "*agent*"+                               , "*allow-unresolved-vars*"+                               , "*assert*"+                               , "*clojure-version*"+                               , "*command-line-args*"+                               , "*compile-files*"+                               , "*compile-path*"+                               , "*current*"+                               , "*e"+                               , "*err*"+                               , "*file*"+                               , "*flush-on-newline*"+                               , "*in*"+                               , "*initial-report-counters*"+                               , "*load-tests*"+                               , "*macro-meta*"+                               , "*math-context*"+                               , "*ns*"+                               , "*out*"+                               , "*print-dup*"+                               , "*print-length*"+                               , "*print-level*"+                               , "*print-meta*"+                               , "*print-readably*"+                               , "*read-eval*"+                               , "*report-counters*"+                               , "*sb*"+                               , "*source-path*"+                               , "*stack*"+                               , "*stack-trace-depth*"+                               , "*state*"+                               , "*test-out*"+                               , "*testing-contexts*"+                               , "*testing-vars*"+                               , "*use-context-classloader*"+                               , "*warn-on-reflection*"+                               ])+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&(),.;[]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "def"+                               , "def-"+                               , "defalias"+                               , "defhinted"+                               , "definline"+                               , "defmacro"+                               , "defmacro-"+                               , "defmethod"+                               , "defmulti"+                               , "defn"+                               , "defn-"+                               , "defn-memo"+                               , "defnk"+                               , "defonce"+                               , "defonce-"+                               , "defprotocol"+                               , "defrecord"+                               , "defstruct"+                               , "defstruct-"+                               , "deftest"+                               , "deftest-"+                               , "deftype"+                               , "defunbound"+                               , "defunbound-"+                               , "defvar"+                               , "defvar-"+                               ])+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Clojure" , "function_decl" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Clojure" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Clojure" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Clojure" , "Level1" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Level0"+          , Context+              { cName = "Level0"+              , cSyntax = "Clojure"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Clojure" , "Level1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Clojure" , "Level1" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Clojure" , "Default" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Level1"+          , Context+              { cName = "Level1"+              , cSyntax = "Clojure"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Clojure" , "Level2" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Clojure" , "Level2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Clojure" , "Default" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Level2"+          , Context+              { cName = "Level2"+              , cSyntax = "Clojure"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Clojure" , "Level3" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Clojure" , "Level3" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Clojure" , "Default" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Level3"+          , Context+              { cName = "Level3"+              , cSyntax = "Clojure"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Clojure" , "Level4" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Clojure" , "Level4" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Clojure" , "Default" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Level4"+          , Context+              { cName = "Level4"+              , cSyntax = "Clojure"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Clojure" , "Level5" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Clojure" , "Level5" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Clojure" , "Default" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Level5"+          , Context+              { cName = "Level5"+              , cSyntax = "Clojure"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Clojure" , "Level6" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Clojure" , "Level6" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Clojure" , "Default" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Level6"+          , Context+              { cName = "Level6"+              , cSyntax = "Clojure"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Clojure" , "Level1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Clojure" , "Level1" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Clojure" , "Default" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SpecialNumber"+          , Context+              { cName = "SpecialNumber"+              , cSyntax = "Clojure"+              , cRules =+                  [ Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Clojure"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\\\."+                              , reCompiled = Just (compileRegex True "#\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "function_decl"+          , Context+              { cName = "function_decl"+              , cSyntax = "Clojure"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*[A-Za-z0-9-+\\<\\>//\\*]*\\s*"+                              , reCompiled =+                                  Just (compileRegex True "\\s*[A-Za-z0-9-+\\<\\>//\\*]*\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor =+      "Dominik Haumann [lisp] modified for clojure by Caspar Hasenclever"+  , sVersion = "5"+  , sLicense = "LGPLv2+"+  , sExtensions = [ "*.clj" , "*.cljs" ]+  , sStartingContext = "Level0"+  }
+ src/Skylighting/Syntax/Cmake.hs view
@@ -0,0 +1,3575 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Cmake (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "CMake"+  , sFilename = "cmake.xml"+  , sShortname = "Cmake"+  , sContexts =+      fromList+        [ ( "Bracketed Comment"+          , Context+              { cName = "Bracketed Comment"+              , cSyntax = "CMake"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#?\\]%1\\]"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Modelines" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "Bracketed String"+          , Context+              { cName = "Bracketed String"+              , cSyntax = "CMake"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\]%1\\]"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "Command Args"+          , Context+              { cName = "Command Args"+              , cSyntax = "CMake"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "AFTER"+                               , "ALIAS"+                               , "ALL"+                               , "ALPHABET"+                               , "AND"+                               , "APPEND"+                               , "APPENDNUMBER_ERRORS"+                               , "APPEND_STRING"+                               , "ARCHIVE"+                               , "ARGS"+                               , "ASCII"+                               , "AUTHOR_WARNING"+                               , "BEFORE"+                               , "BRIEF_DOCS"+                               , "BUILD"+                               , "BUNDLE"+                               , "BYPRODUCTS"+                               , "CACHE"+                               , "CACHED_VARIABLE"+                               , "CDASH_UPLOAD"+                               , "CDASH_UPLOAD_TYPE"+                               , "CLEAR"+                               , "CMAKE_FIND_ROOT_PATH_BOTH"+                               , "CMAKE_FLAGS"+                               , "CODE"+                               , "COMMAND"+                               , "COMMAND_NAME"+                               , "COMMENT"+                               , "COMPARE"+                               , "COMPILE_DEFINITIONS"+                               , "COMPILE_OUTPUT_VARIABLE"+                               , "COMPILE_RESULT_VAR"+                               , "COMPONENT"+                               , "COMPONENTS"+                               , "CONCAT"+                               , "CONDITION"+                               , "CONFIG"+                               , "CONFIGS"+                               , "CONFIGURATION"+                               , "CONFIGURATIONS"+                               , "CONFIGURE"+                               , "CONTENT"+                               , "COPY"+                               , "COPYONLY"+                               , "COPY_FILE"+                               , "COPY_FILE_ERROR"+                               , "CRLF"+                               , "DEFINED"+                               , "DEFINITION"+                               , "DEPENDS"+                               , "DESTINATION"+                               , "DIRECTORY"+                               , "DIRECTORY_PERMISSIONS"+                               , "DOC"+                               , "DOS"+                               , "DOWNLOAD"+                               , "END"+                               , "ENV"+                               , "EQUAL"+                               , "ERROR_FILE"+                               , "ERROR_QUIET"+                               , "ERROR_STRIP_TRAILING_WHITESPACE"+                               , "ERROR_VARIABLE"+                               , "ESCAPE_QUOTES"+                               , "EXACT"+                               , "EXCLUDE"+                               , "EXCLUDE_FROM_ALL"+                               , "EXCLUDE_LABEL"+                               , "EXISTS"+                               , "EXPECTED_HASH"+                               , "EXPECTED_MD5"+                               , "EXPORT"+                               , "EXPORT_LINK_INTERFACE_LIBRARIES"+                               , "EXPR"+                               , "EXTRA_INCLUDE"+                               , "FATAL_ERROR"+                               , "FILE"+                               , "FILES"+                               , "FILES_MATCHING"+                               , "FILE_PERMISSIONS"+                               , "FIND"+                               , "FLAGS"+                               , "FOLLOW_SYMLINKS"+                               , "FORCE"+                               , "FRAMEWORK"+                               , "FULL_DOCS"+                               , "FUNCTION"+                               , "GENERATE"+                               , "GENEX_STRIP"+                               , "GET"+                               , "GLOB"+                               , "GLOBAL"+                               , "GLOB_RECURSE"+                               , "GREATER"+                               , "GROUP_EXECUTE"+                               , "GROUP_READ"+                               , "GUARD"+                               , "GUID"+                               , "HEX"+                               , "HINTS"+                               , "IMPLICIT_DEPENDS"+                               , "IMPORTED"+                               , "IN"+                               , "INACTIVITY_TIMEOUT"+                               , "INCLUDE"+                               , "INCLUDES"+                               , "INCLUDE_INTERNALS"+                               , "INCLUDE_LABEL"+                               , "INHERITED"+                               , "INPUT"+                               , "INPUT_FILE"+                               , "INSERT"+                               , "INSTALL"+                               , "INTERFACE"+                               , "IS_ABSOLUTE"+                               , "IS_DIRECTORY"+                               , "IS_NEWER_THAN"+                               , "IS_SYMLINK"+                               , "ITEMS"+                               , "LABELS"+                               , "LANGUAGES"+                               , "LENGTH"+                               , "LENGTH_MAXIMUM"+                               , "LENGTH_MINIMUM"+                               , "LESS"+                               , "LF"+                               , "LIBRARY"+                               , "LIMIT"+                               , "LIMIT_COUNT"+                               , "LIMIT_INPUT"+                               , "LIMIT_OUTPUT"+                               , "LINK_INTERFACE_LIBRARIES"+                               , "LINK_LIBRARIES"+                               , "LINK_PRIVATE"+                               , "LINK_PUBLIC"+                               , "LISTS"+                               , "LIST_DIRECTORIES"+                               , "LOCK"+                               , "LOG"+                               , "MACOSX_BUNDLE"+                               , "MAIN_DEPENDENCY"+                               , "MAKE_C_IDENTIFIER"+                               , "MAKE_DIRECTORY"+                               , "MATCH"+                               , "MATCHALL"+                               , "MATCHES"+                               , "MD5"+                               , "MESSAGE_NEVER"+                               , "MODULE"+                               , "NAME"+                               , "NAMELINK_ONLY"+                               , "NAMELINK_SKIP"+                               , "NAMES"+                               , "NAMESPACE"+                               , "NAMES_PER_DIR"+                               , "NEW"+                               , "NEWLINE_CONSUME"+                               , "NEWLINE_STYLE"+                               , "NEW_PROCESS"+                               , "NOT"+                               , "NOTEQUAL"+                               , "NO_CMAKE_BUILDS_PATH"+                               , "NO_CMAKE_ENVIRONMENT_PATH"+                               , "NO_CMAKE_FIND_ROOT_PATH"+                               , "NO_CMAKE_PACKAGE_REGISTRY"+                               , "NO_CMAKE_PATH"+                               , "NO_CMAKE_SYSTEM_PACKAGE_REGISTRY"+                               , "NO_CMAKE_SYSTEM_PATH"+                               , "NO_DEFAULT_PATH"+                               , "NO_HEX_CONVERSION"+                               , "NO_MODULE"+                               , "NO_POLICY_SCOPE"+                               , "NO_SOURCE_PERMISSIONS"+                               , "NO_SYSTEM_ENVIRONMENT_PATH"+                               , "NUMBER_ERRORS"+                               , "NUMBER_WARNINGS"+                               , "OBJECT"+                               , "OFF"+                               , "OFFSET"+                               , "OLD"+                               , "ON"+                               , "ONLY_CMAKE_FIND_ROOT_PATH"+                               , "OPTIONAL"+                               , "OPTIONAL_COMPONENTS"+                               , "OPTIONS"+                               , "OR"+                               , "OUTPUT"+                               , "OUTPUT_DIRECTORY"+                               , "OUTPUT_FILE"+                               , "OUTPUT_QUIET"+                               , "OUTPUT_STRIP_TRAILING_WHITESPACE"+                               , "OUTPUT_VARIABLE"+                               , "OWNER_EXECUTE"+                               , "OWNER_READ"+                               , "OWNER_WRITE"+                               , "PACKAGE"+                               , "PARALLEL_LEVEL"+                               , "PARENT_SCOPE"+                               , "PARTS"+                               , "PATHS"+                               , "PATH_SUFFIXES"+                               , "PATH_TO_MESA"+                               , "PATTERN"+                               , "PERMISSIONS"+                               , "PLATFORM"+                               , "POLICY"+                               , "POP"+                               , "POST_BUILD"+                               , "PREORDER"+                               , "PRE_BUILD"+                               , "PRE_LINK"+                               , "PRIVATE"+                               , "PRIVATE_HEADER"+                               , "PROCESS"+                               , "PROGRAM"+                               , "PROGRAMS"+                               , "PROGRAM_ARGS"+                               , "PROJECT_NAME"+                               , "PROPERTIES"+                               , "PROPERTY"+                               , "PUBLIC"+                               , "PUBLIC_HEADER"+                               , "PUSH"+                               , "QUERY"+                               , "QUIET"+                               , "RANDOM"+                               , "RANDOM_SEED"+                               , "RANGE"+                               , "READ"+                               , "READ_WITH_PREFIX"+                               , "REGEX"+                               , "REGULAR_EXPRESSION"+                               , "RELATIVE"+                               , "RELATIVE_PATH"+                               , "RELEASE"+                               , "REMOVE"+                               , "REMOVE_AT"+                               , "REMOVE_DUPLICATES"+                               , "REMOVE_ITEM"+                               , "REMOVE_RECURSE"+                               , "RENAME"+                               , "REPLACE"+                               , "REQUIRED"+                               , "REQUIRED_VARIABLE1"+                               , "REQUIRED_VARIABLE2"+                               , "RESOURCE"+                               , "RESULT"+                               , "RESULT_VAR"+                               , "RESULT_VARIABLE"+                               , "RETRY_COUNT"+                               , "RETRY_DELAY"+                               , "RETURN_VALUE"+                               , "REVERSE"+                               , "RUNTIME"+                               , "RUNTIME_DIRECTORY"+                               , "RUN_OUTPUT_VARIABLE"+                               , "RUN_RESULT_VAR"+                               , "SCHEDULE_RANDOM"+                               , "SCRIPT"+                               , "SEND_ERROR"+                               , "SET"+                               , "SHA1"+                               , "SHA224"+                               , "SHA256"+                               , "SHA384"+                               , "SHA512"+                               , "SHARED"+                               , "SHOW_PROGRESS"+                               , "SORT"+                               , "SOURCE"+                               , "SOURCES"+                               , "START"+                               , "STATIC"+                               , "STATUS"+                               , "STOP_TIME"+                               , "STREQUAL"+                               , "STRGREATER"+                               , "STRIDE"+                               , "STRINGS"+                               , "STRIP"+                               , "STRLESS"+                               , "SUBSTRING"+                               , "SYSTEM"+                               , "TARGET"+                               , "TARGETS"+                               , "TEST"+                               , "TEST_VARIABLE"+                               , "TIMEOUT"+                               , "TIMESTAMP"+                               , "TLS_CAINFO"+                               , "TLS_VERIFY"+                               , "TOLOWER"+                               , "TOUPPER"+                               , "TO_CMAKE_PATH"+                               , "TO_NATIVE_PATH"+                               , "TRACK"+                               , "TYPE"+                               , "UNIX"+                               , "UNIX_COMMAND"+                               , "UNKNOWN"+                               , "UPLOAD"+                               , "UPPER"+                               , "USES_TERMINAL"+                               , "USE_SOURCE_PERMISSIONS"+                               , "UTC"+                               , "UUID"+                               , "VALUE"+                               , "VARIABLE"+                               , "VERBATIM"+                               , "VERSION"+                               , "VERSION_EQUAL"+                               , "VERSION_GREATER"+                               , "VERSION_LESS"+                               , "WARNING"+                               , "WIN32"+                               , "WINDOWS_COMMAND"+                               , "WORKING_DIRECTORY"+                               , "WRITE"+                               ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ABSOLUTE"+                               , "AVAILABLE_PHYSICAL_MEMORY"+                               , "AVAILABLE_VIRTUAL_MEMORY"+                               , "BOOL"+                               , "EXT"+                               , "FILEPATH"+                               , "FQDN"+                               , "HOSTNAME"+                               , "INTERNAL"+                               , "IN_LIST"+                               , "NAME"+                               , "NAME_WE"+                               , "NUMBER_OF_LOGICAL_CORES"+                               , "NUMBER_OF_PHYSICAL_CORES"+                               , "PATH"+                               , "REALPATH"+                               , "STRING"+                               , "TOTAL_PHYSICAL_MEMORY"+                               , "TOTAL_VIRTUAL_MEMORY"+                               ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMP[0-9]+\\b"+                              , reCompiled = Just (compileRegex True "\\bCMP[0-9]+\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ABSTRACT"+                               , "ADDITIONAL_MAKE_CLEAN_FILES"+                               , "ADVANCED"+                               , "ALIASED_TARGET"+                               , "ALLOW_DUPLICATE_CUSTOM_TARGETS"+                               , "ANDROID_API"+                               , "ANDROID_API_MIN"+                               , "ANDROID_GUI"+                               , "ARCHIVE_OUTPUT_DIRECTORY"+                               , "ARCHIVE_OUTPUT_NAME"+                               , "ATTACHED_FILES"+                               , "ATTACHED_FILES_ON_FAIL"+                               , "AUTOGEN_TARGETS_FOLDER"+                               , "AUTOGEN_TARGET_DEPENDS"+                               , "AUTOMOC"+                               , "AUTOMOC_MOC_OPTIONS"+                               , "AUTOMOC_TARGETS_FOLDER"+                               , "AUTORCC"+                               , "AUTORCC_OPTIONS"+                               , "AUTOUIC"+                               , "AUTOUIC_OPTIONS"+                               , "BUILD_WITH_INSTALL_RPATH"+                               , "BUNDLE"+                               , "BUNDLE_EXTENSION"+                               , "CACHE_VARIABLES"+                               , "CLEAN_NO_CUSTOM"+                               , "CMAKE_CONFIGURE_DEPENDS"+                               , "CMAKE_CXX_KNOWN_FEATURES"+                               , "CMAKE_C_KNOWN_FEATURES"+                               , "COMPATIBLE_INTERFACE_BOOL"+                               , "COMPATIBLE_INTERFACE_NUMBER_MAX"+                               , "COMPATIBLE_INTERFACE_NUMBER_MIN"+                               , "COMPATIBLE_INTERFACE_STRING"+                               , "COMPILE_DEFINITIONS"+                               , "COMPILE_FEATURES"+                               , "COMPILE_FLAGS"+                               , "COMPILE_OPTIONS"+                               , "COMPILE_PDB_NAME"+                               , "COMPILE_PDB_OUTPUT_DIRECTORY"+                               , "COST"+                               , "CPACK_DESKTOP_SHORTCUTS"+                               , "CPACK_NEVER_OVERWRITE"+                               , "CPACK_PERMANENT"+                               , "CPACK_STARTUP_SHORTCUTS"+                               , "CPACK_START_MENU_SHORTCUTS"+                               , "CPACK_WIX_ACL"+                               , "CROSSCOMPILING_EMULATOR"+                               , "CXX_EXTENSIONS"+                               , "CXX_STANDARD"+                               , "CXX_STANDARD_REQUIRED"+                               , "C_EXTENSIONS"+                               , "C_STANDARD"+                               , "C_STANDARD_REQUIRED"+                               , "DEBUG_CONFIGURATIONS"+                               , "DEBUG_POSTFIX"+                               , "DEFINE_SYMBOL"+                               , "DEFINITIONS"+                               , "DEPENDS"+                               , "DISABLED_FEATURES"+                               , "ECLIPSE_EXTRA_NATURES"+                               , "ENABLED_FEATURES"+                               , "ENABLED_LANGUAGES"+                               , "ENABLE_EXPORTS"+                               , "ENVIRONMENT"+                               , "EXCLUDE_FROM_ALL"+                               , "EXCLUDE_FROM_DEFAULT_BUILD"+                               , "EXPORT_NAME"+                               , "EXTERNAL_OBJECT"+                               , "EchoString"+                               , "FAIL_REGULAR_EXPRESSION"+                               , "FIND_LIBRARY_USE_LIB64_PATHS"+                               , "FIND_LIBRARY_USE_OPENBSD_VERSIONING"+                               , "FOLDER"+                               , "FRAMEWORK"+                               , "Fortran_FORMAT"+                               , "Fortran_MODULE_DIRECTORY"+                               , "GENERATED"+                               , "GENERATOR_FILE_NAME"+                               , "GLOBAL_DEPENDS_DEBUG_MODE"+                               , "GLOBAL_DEPENDS_NO_CYCLES"+                               , "GNUtoMS"+                               , "HAS_CXX"+                               , "HEADER_FILE_ONLY"+                               , "HELPSTRING"+                               , "IMPLICIT_DEPENDS_INCLUDE_TRANSFORM"+                               , "IMPORTED"+                               , "IMPORTED_CONFIGURATIONS"+                               , "IMPORTED_IMPLIB"+                               , "IMPORTED_LINK_DEPENDENT_LIBRARIES"+                               , "IMPORTED_LINK_INTERFACE_LANGUAGES"+                               , "IMPORTED_LINK_INTERFACE_LIBRARIES"+                               , "IMPORTED_LINK_INTERFACE_MULTIPLICITY"+                               , "IMPORTED_LOCATION"+                               , "IMPORTED_NO_SONAME"+                               , "IMPORTED_SONAME"+                               , "IMPORT_PREFIX"+                               , "IMPORT_SUFFIX"+                               , "INCLUDE_DIRECTORIES"+                               , "INCLUDE_REGULAR_EXPRESSION"+                               , "INSTALL_NAME_DIR"+                               , "INSTALL_RPATH"+                               , "INSTALL_RPATH_USE_LINK_PATH"+                               , "INTERFACE_AUTOUIC_OPTIONS"+                               , "INTERFACE_COMPILE_DEFINITIONS"+                               , "INTERFACE_COMPILE_FEATURES"+                               , "INTERFACE_COMPILE_OPTIONS"+                               , "INTERFACE_INCLUDE_DIRECTORIES"+                               , "INTERFACE_LINK_LIBRARIES"+                               , "INTERFACE_POSITION_INDEPENDENT_CODE"+                               , "INTERFACE_SOURCES"+                               , "INTERFACE_SYSTEM_INCLUDE_DIRECTORIES"+                               , "INTERPROCEDURAL_OPTIMIZATION"+                               , "IN_TRY_COMPILE"+                               , "JOB_POOLS"+                               , "JOB_POOL_COMPILE"+                               , "JOB_POOL_LINK"+                               , "KEEP_EXTENSION"+                               , "LABELS"+                               , "LANGUAGE"+                               , "LIBRARY_OUTPUT_DIRECTORY"+                               , "LIBRARY_OUTPUT_NAME"+                               , "LINKER_LANGUAGE"+                               , "LINK_DEPENDS"+                               , "LINK_DEPENDS_NO_SHARED"+                               , "LINK_DIRECTORIES"+                               , "LINK_FLAGS"+                               , "LINK_INTERFACE_LIBRARIES"+                               , "LINK_INTERFACE_MULTIPLICITY"+                               , "LINK_LIBRARIES"+                               , "LINK_SEARCH_END_STATIC"+                               , "LINK_SEARCH_START_STATIC"+                               , "LISTFILE_STACK"+                               , "LOCATION"+                               , "MACOSX_BUNDLE"+                               , "MACOSX_BUNDLE_INFO_PLIST"+                               , "MACOSX_FRAMEWORK_INFO_PLIST"+                               , "MACOSX_PACKAGE_LOCATION"+                               , "MACOSX_RPATH"+                               , "MACROS"+                               , "MEASUREMENT"+                               , "MODIFIED"+                               , "NAME"+                               , "NO_SONAME"+                               , "NO_SYSTEM_FROM_IMPORTED"+                               , "OBJECT_DEPENDS"+                               , "OBJECT_OUTPUTS"+                               , "OSX_ARCHITECTURES"+                               , "OUTPUT_NAME"+                               , "PACKAGES_FOUND"+                               , "PACKAGES_NOT_FOUND"+                               , "PARENT_DIRECTORY"+                               , "PASS_REGULAR_EXPRESSION"+                               , "PDB_NAME"+                               , "PDB_OUTPUT_DIRECTORY"+                               , "POSITION_INDEPENDENT_CODE"+                               , "POST_INSTALL_SCRIPT"+                               , "PREDEFINED_TARGETS_FOLDER"+                               , "PREFIX"+                               , "PRE_INSTALL_SCRIPT"+                               , "PRIVATE_HEADER"+                               , "PROCESSORS"+                               , "PROJECT_LABEL"+                               , "PUBLIC_HEADER"+                               , "REPORT_UNDEFINED_PROPERTIES"+                               , "REQUIRED_FILES"+                               , "RESOURCE"+                               , "RESOURCE_LOCK"+                               , "RULE_LAUNCH_COMPILE"+                               , "RULE_LAUNCH_CUSTOM"+                               , "RULE_LAUNCH_LINK"+                               , "RULE_MESSAGES"+                               , "RUNTIME_OUTPUT_DIRECTORY"+                               , "RUNTIME_OUTPUT_NAME"+                               , "RUN_SERIAL"+                               , "SKIP_BUILD_RPATH"+                               , "SKIP_RETURN_CODE"+                               , "SOURCES"+                               , "SOVERSION"+                               , "STATIC_LIBRARY_FLAGS"+                               , "STRINGS"+                               , "SUFFIX"+                               , "SYMBOLIC"+                               , "TARGET_ARCHIVES_MAY_BE_SHARED_LIBS"+                               , "TARGET_SUPPORTS_SHARED_LIBS"+                               , "TEST_INCLUDE_FILE"+                               , "TIMEOUT"+                               , "TYPE"+                               , "USE_FOLDERS"+                               , "VALUE"+                               , "VARIABLES"+                               , "VERSION"+                               , "VISIBILITY_INLINES_HIDDEN"+                               , "VS_DEPLOYMENT_CONTENT"+                               , "VS_DEPLOYMENT_LOCATION"+                               , "VS_DOTNET_REFERENCES"+                               , "VS_DOTNET_TARGET_FRAMEWORK_VERSION"+                               , "VS_GLOBAL_KEYWORD"+                               , "VS_GLOBAL_PROJECT_TYPES"+                               , "VS_GLOBAL_ROOTNAMESPACE"+                               , "VS_KEYWORD"+                               , "VS_SCC_AUXPATH"+                               , "VS_SCC_LOCALPATH"+                               , "VS_SCC_PROJECTNAME"+                               , "VS_SCC_PROVIDER"+                               , "VS_SHADER_ENTRYPOINT"+                               , "VS_SHADER_FLAGS"+                               , "VS_SHADER_MODEL"+                               , "VS_SHADER_TYPE"+                               , "VS_WINRT_COMPONENT"+                               , "VS_WINRT_EXTENSIONS"+                               , "VS_WINRT_REFERENCES"+                               , "VS_XAML_TYPE"+                               , "WILL_FAIL"+                               , "WIN32_EXECUTABLE"+                               , "WORKING_DIRECTORY"+                               , "WRAP_EXCLUDE"+                               , "XCODE_EXPLICIT_FILE_TYPE"+                               , "XCODE_LAST_KNOWN_FILE_TYPE"+                               , "XCTEST"+                               ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "COMMANDS" , "DEFINITION" ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CMake" , "Detect Builtin Variables" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CMake" , "Macro Args" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "CMake"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Modelines" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Detect Builtin Variables"+          , Context+              { cName = "Detect Builtin Variables"+              , cSyntax = "CMake"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "APPLE"+                               , "BORLAND"+                               , "BUILD_SHARED_LIBS"+                               , "CMAKE_ABSOLUTE_DESTINATION_FILES"+                               , "CMAKE_ANDROID_API"+                               , "CMAKE_ANDROID_API_MIN"+                               , "CMAKE_ANDROID_GUI"+                               , "CMAKE_APPBUNDLE_PATH"+                               , "CMAKE_AR"+                               , "CMAKE_ARCHIVE_OUTPUT_DIRECTORY"+                               , "CMAKE_ARGC"+                               , "CMAKE_ARGV0"+                               , "CMAKE_AUTOMOC"+                               , "CMAKE_AUTOMOC_MOC_OPTIONS"+                               , "CMAKE_AUTOMOC_RELAXED_MODE"+                               , "CMAKE_AUTORCC"+                               , "CMAKE_AUTORCC_OPTIONS"+                               , "CMAKE_AUTOUIC"+                               , "CMAKE_AUTOUIC_OPTIONS"+                               , "CMAKE_BACKWARDS_COMPATIBILITY"+                               , "CMAKE_BINARY_DIR"+                               , "CMAKE_BUILD_TOOL"+                               , "CMAKE_BUILD_TYPE"+                               , "CMAKE_BUILD_WITH_INSTALL_RPATH"+                               , "CMAKE_CACHEFILE_DIR"+                               , "CMAKE_CACHE_MAJOR_VERSION"+                               , "CMAKE_CACHE_MINOR_VERSION"+                               , "CMAKE_CACHE_PATCH_VERSION"+                               , "CMAKE_CFG_INTDIR"+                               , "CMAKE_CL_64"+                               , "CMAKE_COLOR_MAKEFILE"+                               , "CMAKE_COMMAND"+                               , "CMAKE_COMPILER_2005"+                               , "CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY"+                               , "CMAKE_CONFIGURATION_TYPES"+                               , "CMAKE_CROSSCOMPILING"+                               , "CMAKE_CROSSCOMPILING_EMULATOR"+                               , "CMAKE_CTEST_COMMAND"+                               , "CMAKE_CURRENT_BINARY_DIR"+                               , "CMAKE_CURRENT_LIST_DIR"+                               , "CMAKE_CURRENT_LIST_FILE"+                               , "CMAKE_CURRENT_LIST_LINE"+                               , "CMAKE_CURRENT_SOURCE_DIR"+                               , "CMAKE_CXX_COMPILE_FEATURES"+                               , "CMAKE_CXX_EXTENSIONS"+                               , "CMAKE_CXX_STANDARD"+                               , "CMAKE_CXX_STANDARD_REQUIRED"+                               , "CMAKE_C_COMPILE_FEATURES"+                               , "CMAKE_C_EXTENSIONS"+                               , "CMAKE_C_STANDARD"+                               , "CMAKE_C_STANDARD_REQUIRED"+                               , "CMAKE_DEBUG_POSTFIX"+                               , "CMAKE_DEBUG_TARGET_PROPERTIES"+                               , "CMAKE_DL_LIBS"+                               , "CMAKE_EDIT_COMMAND"+                               , "CMAKE_ERROR_DEPRECATED"+                               , "CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION"+                               , "CMAKE_EXECUTABLE_SUFFIX"+                               , "CMAKE_EXE_LINKER_FLAGS"+                               , "CMAKE_EXPORT_NO_PACKAGE_REGISTRY"+                               , "CMAKE_EXTRA_GENERATOR"+                               , "CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES"+                               , "CMAKE_FIND_LIBRARY_PREFIXES"+                               , "CMAKE_FIND_LIBRARY_SUFFIXES"+                               , "CMAKE_FIND_NO_INSTALL_PREFIX"+                               , "CMAKE_FIND_PACKAGE_NAME"+                               , "CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY"+                               , "CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY"+                               , "CMAKE_FIND_PACKAGE_WARN_NO_MODULE"+                               , "CMAKE_FIND_ROOT_PATH"+                               , "CMAKE_FIND_ROOT_PATH_MODE_INCLUDE"+                               , "CMAKE_FIND_ROOT_PATH_MODE_LIBRARY"+                               , "CMAKE_FIND_ROOT_PATH_MODE_PACKAGE"+                               , "CMAKE_FIND_ROOT_PATH_MODE_PROGRAM"+                               , "CMAKE_FRAMEWORK_PATH"+                               , "CMAKE_Fortran_FORMAT"+                               , "CMAKE_Fortran_MODDIR_DEFAULT"+                               , "CMAKE_Fortran_MODDIR_FLAG"+                               , "CMAKE_Fortran_MODOUT_FLAG"+                               , "CMAKE_Fortran_MODULE_DIRECTORY"+                               , "CMAKE_GENERATOR"+                               , "CMAKE_GENERATOR_PLATFORM"+                               , "CMAKE_GENERATOR_TOOLSET"+                               , "CMAKE_GNUtoMS"+                               , "CMAKE_HOME_DIRECTORY"+                               , "CMAKE_HOST_APPLE"+                               , "CMAKE_HOST_SYSTEM"+                               , "CMAKE_HOST_SYSTEM_NAME"+                               , "CMAKE_HOST_SYSTEM_PROCESSOR"+                               , "CMAKE_HOST_SYSTEM_VERSION"+                               , "CMAKE_HOST_UNIX"+                               , "CMAKE_HOST_WIN32"+                               , "CMAKE_IGNORE_PATH"+                               , "CMAKE_IMPORT_LIBRARY_PREFIX"+                               , "CMAKE_IMPORT_LIBRARY_SUFFIX"+                               , "CMAKE_INCLUDE_CURRENT_DIR"+                               , "CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE"+                               , "CMAKE_INCLUDE_DIRECTORIES_BEFORE"+                               , "CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE"+                               , "CMAKE_INCLUDE_PATH"+                               , "CMAKE_INSTALL_DEFAULT_COMPONENT_NAME"+                               , "CMAKE_INSTALL_MESSAGE"+                               , "CMAKE_INSTALL_NAME_DIR"+                               , "CMAKE_INSTALL_PREFIX"+                               , "CMAKE_INSTALL_RPATH"+                               , "CMAKE_INSTALL_RPATH_USE_LINK_PATH"+                               , "CMAKE_INTERNAL_PLATFORM_ABI"+                               , "CMAKE_JOB_POOL_COMPILE"+                               , "CMAKE_JOB_POOL_LINK"+                               , "CMAKE_LIBRARY_ARCHITECTURE"+                               , "CMAKE_LIBRARY_ARCHITECTURE_REGEX"+                               , "CMAKE_LIBRARY_OUTPUT_DIRECTORY"+                               , "CMAKE_LIBRARY_PATH"+                               , "CMAKE_LIBRARY_PATH_FLAG"+                               , "CMAKE_LINK_DEF_FILE_FLAG"+                               , "CMAKE_LINK_DEPENDS_NO_SHARED"+                               , "CMAKE_LINK_INTERFACE_LIBRARIES"+                               , "CMAKE_LINK_LIBRARY_FILE_FLAG"+                               , "CMAKE_LINK_LIBRARY_FLAG"+                               , "CMAKE_LINK_LIBRARY_SUFFIX"+                               , "CMAKE_MACOSX_BUNDLE"+                               , "CMAKE_MACOSX_RPATH"+                               , "CMAKE_MAJOR_VERSION"+                               , "CMAKE_MAKE_PROGRAM"+                               , "CMAKE_MATCH_COUNT"+                               , "CMAKE_MFC_FLAG"+                               , "CMAKE_MINIMUM_REQUIRED_VERSION"+                               , "CMAKE_MINOR_VERSION"+                               , "CMAKE_MODULE_LINKER_FLAGS"+                               , "CMAKE_MODULE_PATH"+                               , "CMAKE_NOT_USING_CONFIG_FLAGS"+                               , "CMAKE_NO_BUILTIN_CHRPATH"+                               , "CMAKE_NO_SYSTEM_FROM_IMPORTED"+                               , "CMAKE_OBJECT_PATH_MAX"+                               , "CMAKE_OSX_ARCHITECTURES"+                               , "CMAKE_OSX_DEPLOYMENT_TARGET"+                               , "CMAKE_OSX_SYSROOT"+                               , "CMAKE_PARENT_LIST_FILE"+                               , "CMAKE_PATCH_VERSION"+                               , "CMAKE_PDB_OUTPUT_DIRECTORY"+                               , "CMAKE_POSITION_INDEPENDENT_CODE"+                               , "CMAKE_PREFIX_PATH"+                               , "CMAKE_PROGRAM_PATH"+                               , "CMAKE_PROJECT_NAME"+                               , "CMAKE_RANLIB"+                               , "CMAKE_ROOT"+                               , "CMAKE_RUNTIME_OUTPUT_DIRECTORY"+                               , "CMAKE_SCRIPT_MODE_FILE"+                               , "CMAKE_SHARED_LIBRARY_PREFIX"+                               , "CMAKE_SHARED_LIBRARY_SUFFIX"+                               , "CMAKE_SHARED_LINKER_FLAGS"+                               , "CMAKE_SHARED_MODULE_PREFIX"+                               , "CMAKE_SHARED_MODULE_SUFFIX"+                               , "CMAKE_SIZEOF_VOID_P"+                               , "CMAKE_SKIP_BUILD_RPATH"+                               , "CMAKE_SKIP_INSTALL_ALL_DEPENDENCY"+                               , "CMAKE_SKIP_INSTALL_RPATH"+                               , "CMAKE_SKIP_INSTALL_RULES"+                               , "CMAKE_SKIP_RPATH"+                               , "CMAKE_SOURCE_DIR"+                               , "CMAKE_STAGING_PREFIX"+                               , "CMAKE_STANDARD_LIBRARIES"+                               , "CMAKE_STATIC_LIBRARY_PREFIX"+                               , "CMAKE_STATIC_LIBRARY_SUFFIX"+                               , "CMAKE_STATIC_LINKER_FLAGS"+                               , "CMAKE_SYSROOT"+                               , "CMAKE_SYSTEM"+                               , "CMAKE_SYSTEM_IGNORE_PATH"+                               , "CMAKE_SYSTEM_INCLUDE_PATH"+                               , "CMAKE_SYSTEM_LIBRARY_PATH"+                               , "CMAKE_SYSTEM_NAME"+                               , "CMAKE_SYSTEM_PREFIX_PATH"+                               , "CMAKE_SYSTEM_PROCESSOR"+                               , "CMAKE_SYSTEM_PROGRAM_PATH"+                               , "CMAKE_SYSTEM_VERSION"+                               , "CMAKE_TOOLCHAIN_FILE"+                               , "CMAKE_TRY_COMPILE_CONFIGURATION"+                               , "CMAKE_TWEAK_VERSION"+                               , "CMAKE_USER_MAKE_RULES_OVERRIDE"+                               , "CMAKE_USE_RELATIVE_PATHS"+                               , "CMAKE_VERBOSE_MAKEFILE"+                               , "CMAKE_VERSION"+                               , "CMAKE_VISIBILITY_INLINES_HIDDEN"+                               , "CMAKE_VS_DEVENV_COMMAND"+                               , "CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD"+                               , "CMAKE_VS_INTEL_Fortran_PROJECT_VERSION"+                               , "CMAKE_VS_MSBUILD_COMMAND"+                               , "CMAKE_VS_MSDEV_COMMAND"+                               , "CMAKE_VS_NsightTegra_VERSION"+                               , "CMAKE_VS_PLATFORM_NAME"+                               , "CMAKE_VS_PLATFORM_TOOLSET"+                               , "CMAKE_WARN_DEPRECATED"+                               , "CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION"+                               , "CMAKE_WIN32_EXECUTABLE"+                               , "CMAKE_XCODE_PLATFORM_TOOLSET"+                               , "CPACK_ABSOLUTE_DESTINATION_FILES"+                               , "CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY"+                               , "CPACK_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION"+                               , "CPACK_INCLUDE_TOPLEVEL_DIRECTORY"+                               , "CPACK_INSTALL_SCRIPT"+                               , "CPACK_PACKAGING_INSTALL_PREFIX"+                               , "CPACK_SET_DESTDIR"+                               , "CPACK_WARN_ON_ABSOLUTE_INSTALL_DESTINATION"+                               , "CTEST_BINARY_DIRECTORY"+                               , "CTEST_BUILD_COMMAND"+                               , "CTEST_BUILD_NAME"+                               , "CTEST_BZR_COMMAND"+                               , "CTEST_BZR_UPDATE_OPTIONS"+                               , "CTEST_CHECKOUT_COMMAND"+                               , "CTEST_CONFIGURATION_TYPE"+                               , "CTEST_CONFIGURE_COMMAND"+                               , "CTEST_COVERAGE_COMMAND"+                               , "CTEST_COVERAGE_EXTRA_FLAGS"+                               , "CTEST_CURL_OPTIONS"+                               , "CTEST_CVS_CHECKOUT"+                               , "CTEST_CVS_COMMAND"+                               , "CTEST_CVS_UPDATE_OPTIONS"+                               , "CTEST_DROP_LOCATION"+                               , "CTEST_DROP_METHOD"+                               , "CTEST_DROP_SITE"+                               , "CTEST_DROP_SITE_CDASH"+                               , "CTEST_DROP_SITE_PASSWORD"+                               , "CTEST_DROP_SITE_USER"+                               , "CTEST_GIT_COMMAND"+                               , "CTEST_GIT_UPDATE_CUSTOM"+                               , "CTEST_GIT_UPDATE_OPTIONS"+                               , "CTEST_HG_COMMAND"+                               , "CTEST_HG_UPDATE_OPTIONS"+                               , "CTEST_MEMORYCHECK_COMMAND"+                               , "CTEST_MEMORYCHECK_COMMAND_OPTIONS"+                               , "CTEST_MEMORYCHECK_SANITIZER_OPTIONS"+                               , "CTEST_MEMORYCHECK_SUPPRESSIONS_FILE"+                               , "CTEST_MEMORYCHECK_TYPE"+                               , "CTEST_NIGHTLY_START_TIME"+                               , "CTEST_P4_CLIENT"+                               , "CTEST_P4_COMMAND"+                               , "CTEST_P4_OPTIONS"+                               , "CTEST_P4_UPDATE_OPTIONS"+                               , "CTEST_SCP_COMMAND"+                               , "CTEST_SITE"+                               , "CTEST_SOURCE_DIRECTORY"+                               , "CTEST_SVN_COMMAND"+                               , "CTEST_SVN_OPTIONS"+                               , "CTEST_SVN_UPDATE_OPTIONS"+                               , "CTEST_TEST_TIMEOUT"+                               , "CTEST_TRIGGER_SITE"+                               , "CTEST_UPDATE_COMMAND"+                               , "CTEST_UPDATE_OPTIONS"+                               , "CTEST_UPDATE_VERSION_ONLY"+                               , "CTEST_USE_LAUNCHERS"+                               , "CYGWIN"+                               , "ENV"+                               , "EXECUTABLE_OUTPUT_PATH"+                               , "GHS-MULTI"+                               , "LIBRARY_OUTPUT_PATH"+                               , "MINGW"+                               , "MSVC"+                               , "MSVC10"+                               , "MSVC11"+                               , "MSVC12"+                               , "MSVC14"+                               , "MSVC60"+                               , "MSVC70"+                               , "MSVC71"+                               , "MSVC80"+                               , "MSVC90"+                               , "MSVC_IDE"+                               , "MSVC_VERSION"+                               , "PROJECT_BINARY_DIR"+                               , "PROJECT_NAME"+                               , "PROJECT_SOURCE_DIR"+                               , "PROJECT_VERSION"+                               , "PROJECT_VERSION_MAJOR"+                               , "PROJECT_VERSION_MINOR"+                               , "PROJECT_VERSION_PATCH"+                               , "PROJECT_VERSION_TWEAK"+                               , "UNIX"+                               , "WIN32"+                               , "WINCE"+                               , "WINDOWS_PHONE"+                               , "WINDOWS_STORE"+                               , "XCODE_VERSION"+                               ])+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "CMake" , "Detect More Builtin Variables" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Detect Generator Expressions"+          , Context+              { cName = "Detect Generator Expressions"+              , cSyntax = "CMake"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '$' '<'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CMake" , "Generator Expression" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Detect More Builtin Variables"+          , Context+              { cName = "Detect More Builtin Variables"+              , cSyntax = "CMake"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_ARCHIVE_OUTPUT_DIRECTORY_[A-Za-z_][A-Za-z_0-9]*\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_ARCHIVE_OUTPUT_DIRECTORY_[A-Za-z_][A-Za-z_0-9]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_COMPILER_IS_GNU[A-Za-z_][A-Za-z_0-9]*\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_COMPILER_IS_GNU[A-Za-z_][A-Za-z_0-9]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_COMPILE_PDB_OUTPUT_DIRECTORY_[A-Za-z_][A-Za-z_0-9]*\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_COMPILE_PDB_OUTPUT_DIRECTORY_[A-Za-z_][A-Za-z_0-9]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_DISABLE_FIND_PACKAGE_[A-Za-z_][A-Za-z_0-9]*\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_DISABLE_FIND_PACKAGE_[A-Za-z_][A-Za-z_0-9]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_EXE_LINKER_FLAGS_[A-Za-z_][A-Za-z_0-9]*\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_EXE_LINKER_FLAGS_[A-Za-z_][A-Za-z_0-9]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_LIBRARY_OUTPUT_DIRECTORY_[A-Za-z_][A-Za-z_0-9]*\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_LIBRARY_OUTPUT_DIRECTORY_[A-Za-z_][A-Za-z_0-9]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_MAP_IMPORTED_CONFIG_[A-Za-z_][A-Za-z_0-9]*\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_MAP_IMPORTED_CONFIG_[A-Za-z_][A-Za-z_0-9]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_MODULE_LINKER_FLAGS_[A-Za-z_][A-Za-z_0-9]*\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_MODULE_LINKER_FLAGS_[A-Za-z_][A-Za-z_0-9]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_PDB_OUTPUT_DIRECTORY_[A-Za-z_][A-Za-z_0-9]*\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_PDB_OUTPUT_DIRECTORY_[A-Za-z_][A-Za-z_0-9]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_POLICY_DEFAULT_CMP[0-9]+\\b"+                              , reCompiled =+                                  Just (compileRegex True "\\bCMAKE_POLICY_DEFAULT_CMP[0-9]+\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_POLICY_WARNING_CMP[0-9]+\\b"+                              , reCompiled =+                                  Just (compileRegex True "\\bCMAKE_POLICY_WARNING_CMP[0-9]+\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_PROJECT_[A-Za-z_][A-Za-z_0-9]*_INCLUDE\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_PROJECT_[A-Za-z_][A-Za-z_0-9]*_INCLUDE\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_RUNTIME_OUTPUT_DIRECTORY_[A-Za-z_][A-Za-z_0-9]*\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_RUNTIME_OUTPUT_DIRECTORY_[A-Za-z_][A-Za-z_0-9]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_SHARED_LINKER_FLAGS_[A-Za-z_][A-Za-z_0-9]*\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_SHARED_LINKER_FLAGS_[A-Za-z_][A-Za-z_0-9]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_STATIC_LINKER_FLAGS_[A-Za-z_][A-Za-z_0-9]*\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_STATIC_LINKER_FLAGS_[A-Za-z_][A-Za-z_0-9]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_USER_MAKE_RULES_OVERRIDE_[A-Za-z_][A-Za-z_0-9]*\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_USER_MAKE_RULES_OVERRIDE_[A-Za-z_][A-Za-z_0-9]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_XCODE_ATTRIBUTE_[A-Za-z_][A-Za-z_0-9]*\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_XCODE_ATTRIBUTE_[A-Za-z_][A-Za-z_0-9]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_ARCHIVE_APPEND\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_ARCHIVE_APPEND\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_ARCHIVE_CREATE\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_ARCHIVE_CREATE\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_ARCHIVE_FINISH\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_ARCHIVE_FINISH\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_COMPILER\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_COMPILER\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_COMPILER_ABI\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_COMPILER_ABI\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_COMPILER_EXTERNAL_TOOLCHAIN\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_COMPILER_EXTERNAL_TOOLCHAIN\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_COMPILER_ID\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_COMPILER_ID\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_COMPILER_LOADED\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_COMPILER_LOADED\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_COMPILER_TARGET\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_COMPILER_TARGET\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_COMPILER_VERSION\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_COMPILER_VERSION\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_COMPILE_OBJECT\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_COMPILE_OBJECT\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_CREATE_SHARED_LIBRARY\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_CREATE_SHARED_LIBRARY\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_CREATE_SHARED_MODULE\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_CREATE_SHARED_MODULE\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_CREATE_STATIC_LIBRARY\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_CREATE_STATIC_LIBRARY\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_FLAGS\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_FLAGS\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_FLAGS_DEBUG\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_FLAGS_DEBUG\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_FLAGS_MINSIZEREL\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_FLAGS_MINSIZEREL\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_FLAGS_RELEASE\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_FLAGS_RELEASE\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_FLAGS_RELWITHDEBINFO\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_FLAGS_RELWITHDEBINFO\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_GHS_KERNEL_FLAGS_DEBUG\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_GHS_KERNEL_FLAGS_DEBUG\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_GHS_KERNEL_FLAGS_MINSIZEREL\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_GHS_KERNEL_FLAGS_MINSIZEREL\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_GHS_KERNEL_FLAGS_RELEASE\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_GHS_KERNEL_FLAGS_RELEASE\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_GHS_KERNEL_FLAGS_RELWITHDEBINFO\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_GHS_KERNEL_FLAGS_RELWITHDEBINFO\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_IGNORE_EXTENSIONS\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_IGNORE_EXTENSIONS\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_IMPLICIT_INCLUDE_DIRECTORIES\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_IMPLICIT_INCLUDE_DIRECTORIES\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_IMPLICIT_LINK_DIRECTORIES\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_IMPLICIT_LINK_DIRECTORIES\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_IMPLICIT_LINK_LIBRARIES\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_IMPLICIT_LINK_LIBRARIES\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_INCLUDE_WHAT_YOU_USE\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_INCLUDE_WHAT_YOU_USE\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_LIBRARY_ARCHITECTURE\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_LIBRARY_ARCHITECTURE\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_LINKER_PREFERENCE\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_LINKER_PREFERENCE\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_LINKER_PREFERENCE_PROPAGATES\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_LINKER_PREFERENCE_PROPAGATES\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_LINK_EXECUTABLE\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_LINK_EXECUTABLE\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_OUTPUT_EXTENSION\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_OUTPUT_EXTENSION\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_PLATFORM_ID\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_PLATFORM_ID\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_POSTFIX\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_POSTFIX\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_SIMULATE_ID\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_SIMULATE_ID\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_SIMULATE_VERSION\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_SIMULATE_VERSION\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_SIZEOF_DATA_PTR\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_SIZEOF_DATA_PTR\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_SOURCE_FILE_EXTENSIONS\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_SOURCE_FILE_EXTENSIONS\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_VISIBILITY_PRESET\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bCMAKE_[A-Za-z_][A-Za-z_0-9]*_VISIBILITY_PRESET\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[A-Za-z_][A-Za-z_0-9]*_BINARY_DIR\\b"+                              , reCompiled =+                                  Just (compileRegex True "\\b[A-Za-z_][A-Za-z_0-9]*_BINARY_DIR\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[A-Za-z_][A-Za-z_0-9]*_SOURCE_DIR\\b"+                              , reCompiled =+                                  Just (compileRegex True "\\b[A-Za-z_][A-Za-z_0-9]*_SOURCE_DIR\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[A-Za-z_][A-Za-z_0-9]*_VERSION\\b"+                              , reCompiled =+                                  Just (compileRegex True "\\b[A-Za-z_][A-Za-z_0-9]*_VERSION\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[A-Za-z_][A-Za-z_0-9]*_VERSION_MAJOR\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex True "\\b[A-Za-z_][A-Za-z_0-9]*_VERSION_MAJOR\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[A-Za-z_][A-Za-z_0-9]*_VERSION_MINOR\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex True "\\b[A-Za-z_][A-Za-z_0-9]*_VERSION_MINOR\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[A-Za-z_][A-Za-z_0-9]*_VERSION_PATCH\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex True "\\b[A-Za-z_][A-Za-z_0-9]*_VERSION_PATCH\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[A-Za-z_][A-Za-z_0-9]*_VERSION_TWEAK\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex True "\\b[A-Za-z_][A-Za-z_0-9]*_VERSION_TWEAK\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Detect Variables"+          , Context+              { cName = "Detect Variables"+              , cSyntax = "CMake"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$ENV\\{\\s*[\\w-]+\\s*\\}"+                              , reCompiled =+                                  Just (compileRegex True "\\$ENV\\{\\s*[\\w-]+\\s*\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '{'+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CMake" , "VarSubst" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DetectSimpleGEEnd"+          , Context+              { cName = "DetectSimpleGEEnd"+              , cSyntax = "CMake"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Generator Expression"+          , Context+              { cName = "Generator Expression"+              , cSyntax = "CMake"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "CMake" , "Detect Generator Expressions" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ANGLE-R"+                               , "COMMA"+                               , "CONFIGURATION"+                               , "INSTALL_PREFIX"+                               , "SEMICOLON"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CMake" , "DetectSimpleGEEnd" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "0"+                               , "1"+                               , "AND"+                               , "ANGLE-R"+                               , "BOOL"+                               , "BUILD_INTERFACE"+                               , "COMMA"+                               , "COMPILER_FEATURES"+                               , "CONFIG"+                               , "CONFIGURATION"+                               , "CXX_COMPILER_ID"+                               , "CXX_COMPILER_VERSION"+                               , "C_COMPILER_ID"+                               , "C_COMPILER_VERSION"+                               , "EQUAL"+                               , "INSTALL_INTERFACE"+                               , "INSTALL_PREFIX"+                               , "JOIN"+                               , "LINK_ONLY"+                               , "LOWER_CASE"+                               , "MAKE_C_IDENTIFIER"+                               , "NOT"+                               , "OR"+                               , "PLATFORM_ID"+                               , "SEMICOLON"+                               , "STREQUAL"+                               , "TARGET_DIR"+                               , "TARGET_FILE"+                               , "TARGET_FILE_DIR"+                               , "TARGET_FILE_NAME"+                               , "TARGET_LINKER_FILE"+                               , "TARGET_LINKER_FILE_DIR"+                               , "TARGET_LINKER_FILE_NAME"+                               , "TARGET_NAME"+                               , "TARGET_OBJECTS"+                               , "TARGET_PDB_FILE"+                               , "TARGET_PDB_FILE_DIR"+                               , "TARGET_PDB_FILE_NAME"+                               , "TARGET_POLICY"+                               , "TARGET_PROPERTY"+                               , "TARGET_SONAME_FILE"+                               , "TARGET_SONAME_FILE_DIR"+                               , "TARGET_SONAME_FILE_NAME"+                               , "UPPER_CASE"+                               , "VERSION_EQUAL"+                               , "VERSION_GREATER"+                               , "VERSION_LESS"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CMake" , "Detect Variables" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Macro Args"+          , Context+              { cName = "Macro Args"+              , cSyntax = "CMake"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[\"$n\\\\]"+                              , reCompiled = Just (compileRegex True "\\\\[\"$n\\\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CMake" , "String" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[(=*)\\["+                              , reCompiled = Just (compileRegex True "\\[(=*)\\[")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CMake" , "Bracketed String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CMake" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CMake" , "Detect Builtin Variables" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CMake" , "Detect Variables" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "CMake" , "Detect Generator Expressions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal Text"+          , Context+              { cName = "Normal Text"+              , cSyntax = "CMake"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = WordDetect "if"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CMake" , "Command Args" ) ]+                      }+                  , Rule+                      { rMatcher = WordDetect "else"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CMake" , "Command Args" ) ]+                      }+                  , Rule+                      { rMatcher = WordDetect "elseif"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CMake" , "Command Args" ) ]+                      }+                  , Rule+                      { rMatcher = WordDetect "endif"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CMake" , "Command Args" ) ]+                      }+                  , Rule+                      { rMatcher = WordDetect "macro"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CMake" , "Command Args" ) ]+                      }+                  , Rule+                      { rMatcher = WordDetect "endmacro"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CMake" , "Command Args" ) ]+                      }+                  , Rule+                      { rMatcher = WordDetect "foreach"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CMake" , "Command Args" ) ]+                      }+                  , Rule+                      { rMatcher = WordDetect "endforeach"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CMake" , "Command Args" ) ]+                      }+                  , Rule+                      { rMatcher = WordDetect "while"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CMake" , "Command Args" ) ]+                      }+                  , Rule+                      { rMatcher = WordDetect "endwhile"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CMake" , "Command Args" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "add_compile_options"+                               , "add_custom_command"+                               , "add_custom_target"+                               , "add_definitions"+                               , "add_dependencies"+                               , "add_executable"+                               , "add_library"+                               , "add_subdirectory"+                               , "add_test"+                               , "aux_source_directory"+                               , "break"+                               , "build_command"+                               , "build_name"+                               , "cmake_host_system_information"+                               , "cmake_minimum_required"+                               , "cmake_policy"+                               , "configure_file"+                               , "continue"+                               , "create_test_sourcelist"+                               , "ctest_build"+                               , "ctest_configure"+                               , "ctest_coverage"+                               , "ctest_empty_binary_directory"+                               , "ctest_memcheck"+                               , "ctest_read_custom_files"+                               , "ctest_run_script"+                               , "ctest_sleep"+                               , "ctest_start"+                               , "ctest_submit"+                               , "ctest_test"+                               , "ctest_update"+                               , "ctest_upload"+                               , "define_property"+                               , "else"+                               , "elseif"+                               , "enable_language"+                               , "enable_testing"+                               , "endforeach"+                               , "endfunction"+                               , "endif"+                               , "endmacro"+                               , "endwhile"+                               , "exec_program"+                               , "execute_process"+                               , "export"+                               , "export_library_dependencies"+                               , "file"+                               , "find_file"+                               , "find_library"+                               , "find_package"+                               , "find_path"+                               , "find_program"+                               , "fltk_wrap_ui"+                               , "foreach"+                               , "function"+                               , "get_cmake_property"+                               , "get_directory_property"+                               , "get_filename_component"+                               , "get_property"+                               , "get_source_file_property"+                               , "get_target_property"+                               , "get_test_property"+                               , "if"+                               , "include"+                               , "include_directories"+                               , "include_external_msproject"+                               , "include_regular_expression"+                               , "install"+                               , "install_files"+                               , "install_programs"+                               , "install_targets"+                               , "link_directories"+                               , "link_libraries"+                               , "list"+                               , "load_cache"+                               , "load_command"+                               , "macro"+                               , "make_directory"+                               , "mark_as_advanced"+                               , "math"+                               , "message"+                               , "option"+                               , "output_required_files"+                               , "project"+                               , "qt_wrap_cpp"+                               , "qt_wrap_ui"+                               , "remove"+                               , "remove_definitions"+                               , "return"+                               , "separate_arguments"+                               , "set"+                               , "set_directory_properties"+                               , "set_property"+                               , "set_source_files_properties"+                               , "set_target_properties"+                               , "set_tests_properties"+                               , "site_name"+                               , "source_group"+                               , "string"+                               , "subdir_depends"+                               , "subdirs"+                               , "target_compile_definitions"+                               , "target_compile_features"+                               , "target_compile_options"+                               , "target_include_directories"+                               , "target_link_libraries"+                               , "target_sources"+                               , "try_compile"+                               , "try_run"+                               , "unset"+                               , "use_mangled_mesa"+                               , "utility_source"+                               , "variable_requires"+                               , "variable_watch"+                               , "while"+                               , "write_file"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CMake" , "Command Args" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "itk_wrap_tcl"+                               , "vtk_make_instantiator"+                               , "vtk_wrap_java"+                               , "vtk_wrap_python"+                               , "vtk_wrap_tcl"+                               ])+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*BEGIN.*$"+                              , reCompiled = Just (compileRegex True "#\\s*BEGIN.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*END.*$"+                              , reCompiled = Just (compileRegex True "#\\s*END.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\[(=*)\\[\\.rst:"+                              , reCompiled = Just (compileRegex True "#\\[(=*)\\[\\.rst:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "CMake" , "RST Documentation" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\[(=*)\\["+                              , reCompiled = Just (compileRegex True "#\\[(=*)\\[")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "CMake" , "Bracketed Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CMake" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CMake" , "Detect Variables" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\w+\\s*(?=\\()"+                              , reCompiled = Just (compileRegex True "\\w+\\s*(?=\\()")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CMake" , "Macro Args" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RST Documentation"+          , Context+              { cName = "RST Documentation"+              , cSyntax = "CMake"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#?\\]%1\\]"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "CMake"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"(?=[ );]|$)"+                              , reCompiled = Just (compileRegex True "\"(?=[ );]|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[\"$nrt\\\\]"+                              , reCompiled = Just (compileRegex True "\\\\[\"$nrt\\\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CMake" , "Detect Variables" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "CMake" , "Detect Generator Expressions" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "VarSubst"+          , Context+              { cName = "VarSubst"+              , cSyntax = "CMake"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "CMake" , "Detect Builtin Variables" )+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CMake" , "Detect Variables" )+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = VariableTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Alexander Neundorf (neundorf@kde.org)"+  , sVersion = "3"+  , sLicense = "LGPLv2+"+  , sExtensions = [ "CMakeLists.txt" , "*.cmake" , "*.cmake.in" ]+  , sStartingContext = "Normal Text"+  }
+ src/Skylighting/Syntax/Coffee.hs view
@@ -0,0 +1,937 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Coffee (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "CoffeeScript"+  , sFilename = "coffee.xml"+  , sShortname = "Coffee"+  , sContexts =+      fromList+        [ ( "Class"+          , Context+              { cName = "Class"+              , cSyntax = "CoffeeScript"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[@$:.\\w\\[\\]]+"+                              , reCompiled = Just (compileRegex True "[@$:.\\w\\[\\]]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "CoffeeScript"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts_indent" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Embedding"+          , Context+              { cName = "Embedding"+              , cSyntax = "CoffeeScript"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Heredoc"+          , Context+              { cName = "Heredoc"+              , cSyntax = "CoffeeScript"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "'''"+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Javascript"+          , Context+              { cName = "Javascript"+              , cSyntax = "CoffeeScript"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "JavaScript" , "Normal" )+                      , rAttribute = AlertTok+                      , rIncludeAttribute = True+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = AlertTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Multiline Comment"+          , Context+              { cName = "Multiline Comment"+              , cSyntax = "CoffeeScript"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "###"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts_indent" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Multiline Regex"+          , Context+              { cName = "Multiline Regex"+              , cSyntax = "CoffeeScript"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CoffeeScript" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "///[mig]{0,3}"+                              , reCompiled = Just (compileRegex True "///[mig]{0,3}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "CoffeeScript"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !#%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "and"+                               , "break"+                               , "by"+                               , "catch"+                               , "constructor"+                               , "continue"+                               , "delete"+                               , "do"+                               , "else"+                               , "finally"+                               , "for"+                               , "if"+                               , "in"+                               , "is"+                               , "isnt"+                               , "loop"+                               , "not"+                               , "of"+                               , "or"+                               , "return"+                               , "super"+                               , "switch"+                               , "then"+                               , "throw"+                               , "try"+                               , "typeof"+                               , "unless"+                               , "until"+                               , "when"+                               , "where"+                               , "while"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !#%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "class" , "extends" , "instanceof" , "new" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CoffeeScript" , "Class" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !#%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Infinity"+                               , "NaN"+                               , "false"+                               , "no"+                               , "null"+                               , "off"+                               , "on"+                               , "true"+                               , "undefined"+                               , "yes"+                               ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !#%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "__bind"+                               , "__extends"+                               , "__hasProp"+                               , "__indexOf"+                               , "__slice"+                               , "case"+                               , "const"+                               , "default"+                               , "enum"+                               , "export"+                               , "function"+                               , "import"+                               , "let"+                               , "native"+                               , "var"+                               , "void"+                               , "with"+                               ])+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !#%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Array"+                               , "Boolean"+                               , "Date"+                               , "Function"+                               , "Math"+                               , "Number"+                               , "Object"+                               , "RegExp"+                               , "String"+                               , "clearInterval"+                               , "clearTimeout"+                               , "console"+                               , "decodeURI"+                               , "decodeURIComponent"+                               , "encodeURI"+                               , "encodeURIComponent"+                               , "escape"+                               , "eval"+                               , "isFinite"+                               , "isNaN"+                               , "parseFloat"+                               , "parseInt"+                               , "setInterval"+                               , "setTimeout"+                               , "unescape"+                               ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !#%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "alert"+                               , "document"+                               , "history"+                               , "location"+                               , "navigator"+                               , "prompt"+                               , "screen"+                               , "window"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !#%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "GLOBAL" , "exports" , "process" , "require" ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(@[_$a-zA-Z][$\\w]*|\\bthis)\\b"+                              , reCompiled =+                                  Just (compileRegex True "(@[_$a-zA-Z][$\\w]*|\\bthis)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\((\\'[^']*'|\"[^\"]*\"|[^()])*\\))?\\s*(-|=)>"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False "(\\((\\'[^']*'|\"[^\"]*\"|[^()])*\\))?\\s*(-|=)>")+                              , reCaseSensitive = False+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[_$a-z][$\\w]*\\b"+                              , reCompiled = Just (compileRegex False "[_$a-z][$\\w]*\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "'''"+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CoffeeScript" , "Heredoc" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "\"\"\""+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CoffeeScript" , "Rich Heredoc" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CoffeeScript" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CoffeeScript" , "Rich String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CoffeeScript" , "Javascript" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "###"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "CoffeeScript" , "Multiline Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CoffeeScript" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "///"+                              , reCompiled = Just (compileRegex True "///")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CoffeeScript" , "Multiline Regex" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/([^/\\\\\\r\\n]|\\\\.)*/[mig]{0,3}"+                              , reCompiled =+                                  Just (compileRegex True "/([^/\\\\\\r\\n]|\\\\.)*/[mig]{0,3}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "():!%&+,-/.*<=>?[]|~^;{}"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Rich Heredoc"+          , Context+              { cName = "Rich Heredoc"+              , cSyntax = "CoffeeScript"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '{'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CoffeeScript" , "Embedding" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "\"\"\""+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Rich String"+          , Context+              { cName = "Rich String"+              , cSyntax = "CoffeeScript"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '{'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CoffeeScript" , "Embedding" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "CoffeeScript"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Max Shawabkeh (max99x@gmail.com)"+  , sVersion = "2"+  , sLicense = "MIT"+  , sExtensions = [ "Cakefile" , "*.coffee" , "*.coco" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Coldfusion.hs view
@@ -0,0 +1,2238 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Coldfusion (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "ColdFusion"+  , sFilename = "coldfusion.xml"+  , sShortname = "Coldfusion"+  , sContexts =+      fromList+        [ ( "Normal Text"+          , Context+              { cName = "Normal Text"+              , cSyntax = "ColdFusion"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<!---"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ColdFusion" , "ctxCF Comment" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ColdFusion" , "ctxHTML Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<[cC][fF][sS][cC][rR][iI][pP][tT]"+                              , reCompiled =+                                  Just (compileRegex True "<[cC][fF][sS][cC][rR][iI][pP][tT]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ColdFusion" , "ctxCFSCRIPT Tag" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<[sS][cC][rR][iI][pP][tT]"+                              , reCompiled = Just (compileRegex True "<[sS][cC][rR][iI][pP][tT]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ColdFusion" , "ctxSCRIPT Tag" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<[sS][tT][yY][lL][eE]"+                              , reCompiled = Just (compileRegex True "<[sS][tT][yY][lL][eE]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ColdFusion" , "ctxSTYLE Tag" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '&'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ColdFusion" , "ctxHTML Entities" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\/?[cC][fF]_"+                              , reCompiled = Just (compileRegex True "<\\/?[cC][fF]_")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ColdFusion" , "ctxCustom Tag" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\/?[cC][fF][xX]_"+                              , reCompiled = Just (compileRegex True "<\\/?[cC][fF][xX]_")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ColdFusion" , "ctxCFX Tag" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\/?[cC][fF]"+                              , reCompiled = Just (compileRegex True "<\\/?[cC][fF]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ColdFusion" , "ctxCF Tag" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\/?([tT][aAhHbBfFrRdD])|([cC][aA][pP][tT])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "<\\/?([tT][aAhHbBfFrRdD])|([cC][aA][pP][tT])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ColdFusion" , "ctxTable Tag" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\/?[aA] "+                              , reCompiled = Just (compileRegex True "<\\/?[aA] ")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ColdFusion" , "ctxAnchor Tag" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\/?[iI][mM][gG] "+                              , reCompiled = Just (compileRegex True "<\\/?[iI][mM][gG] ")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ColdFusion" , "ctxImage Tag" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<!?\\/?[a-zA-Z0-9_]+"+                              , reCompiled = Just (compileRegex True "<!?\\/?[a-zA-Z0-9_]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ColdFusion" , "ctxTag" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ctxAnchor Tag"+          , Context+              { cName = "ctxAnchor Tag"+              , cSyntax = "ColdFusion"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"[^\"]*\""+                              , reCompiled = Just (compileRegex True "\"[^\"]*\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'[^']*'"+                              , reCompiled = Just (compileRegex True "'[^']*'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ctxC Style Comment"+          , Context+              { cName = "ctxC Style Comment"+              , cSyntax = "ColdFusion"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ctxCF Comment"+          , Context+              { cName = "ctxCF Comment"+              , cSyntax = "ColdFusion"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "--->"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ctxCF Tag"+          , Context+              { cName = "ctxCF Tag"+              , cSyntax = "ColdFusion"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"[^\"]*\""+                              , reCompiled = Just (compileRegex True "\"[^\"]*\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'[^']*'"+                              , reCompiled = Just (compileRegex True "'[^']*'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ctxCFSCRIPT Block"+          , Context+              { cName = "ctxCFSCRIPT Block"+              , cSyntax = "ColdFusion"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ColdFusion" , "ctxC Style Comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "ColdFusion" , "ctxOne Line Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"[^\"]*\""+                              , reCompiled = Just (compileRegex True "\"[^\"]*\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'[^']*'"+                              , reCompiled = Just (compileRegex True "'[^']*'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "[()[\\]=+-*/]+"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "{}"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "break"+                               , "case"+                               , "catch"+                               , "continue"+                               , "default"+                               , "do"+                               , "else"+                               , "for"+                               , "function"+                               , "if"+                               , "in"+                               , "return"+                               , "switch"+                               , "try"+                               , "var"+                               , "while"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "Abs"+                               , "ACos"+                               , "ArrayAppend"+                               , "ArrayAvg"+                               , "ArrayClear"+                               , "ArrayDeleteAt"+                               , "ArrayInsertAt"+                               , "ArrayIsEmpty"+                               , "ArrayLen"+                               , "ArrayMax"+                               , "ArrayMin"+                               , "ArrayNew"+                               , "ArrayPrepend"+                               , "ArrayResize"+                               , "ArraySet"+                               , "ArraySort"+                               , "ArraySum"+                               , "ArraySwap"+                               , "ArrayToList"+                               , "Asc"+                               , "ASin"+                               , "Atn"+                               , "BitAnd"+                               , "BitMaskClear"+                               , "BitMaskRead"+                               , "BitMaskSet"+                               , "BitNot"+                               , "BitOr"+                               , "BitSHLN"+                               , "BitSHRN"+                               , "BitXor"+                               , "Ceiling"+                               , "Chr"+                               , "CJustify"+                               , "Compare"+                               , "CompareNoCase"+                               , "Cos"+                               , "CreateDate"+                               , "CreateDateTime"+                               , "CreateObject"+                               , "CreateODBCDate"+                               , "CreateODBCDateTime"+                               , "CreateODBCTime"+                               , "CreateTime"+                               , "CreateTimeSpan"+                               , "CreateUUID"+                               , "DateAdd"+                               , "DateCompare"+                               , "DateConvert"+                               , "DateDiff"+                               , "DateFormat"+                               , "DatePart"+                               , "Day"+                               , "DayOfWeek"+                               , "DayOfWeekAsString"+                               , "DayOfYear"+                               , "DaysInMonth"+                               , "DaysInYear"+                               , "DE"+                               , "DecimalFormat"+                               , "DecrementValue"+                               , "Decrypt"+                               , "DeleteClientVariable"+                               , "DirectoryExists"+                               , "DollarFormat"+                               , "Duplicate"+                               , "Encrypt"+                               , "Evaluate"+                               , "Exp"+                               , "ExpandPath"+                               , "FileExists"+                               , "Find"+                               , "FindNoCase"+                               , "FindOneOf"+                               , "FirstDayOfMonth"+                               , "Fix"+                               , "FormatBaseN"+                               , "GetAuthUser"+                               , "GetBaseTagData"+                               , "GetBaseTagList"+                               , "GetBaseTemplatePath"+                               , "GetClientVariablesList"+                               , "GetCurrentTemplatePath"+                               , "GetDirectoryFromPath"+                               , "GetException"+                               , "GetFileFromPath"+                               , "GetFunctionList"+                               , "GetHttpRequestData"+                               , "GetHttpTimeString"+                               , "GetK2ServerDocCount"+                               , "GetK2ServerDocCountLimit"+                               , "GetLocale"+                               , "GetMetaData"+                               , "GetMetricData"+                               , "GetPageContext"+                               , "GetProfileSections"+                               , "GetProfileString"+                               , "GetServiceSettings"+                               , "GetTempDirectory"+                               , "GetTempFile"+                               , "GetTemplatePath"+                               , "GetTickCount"+                               , "GetTimeZoneInfo"+                               , "GetToken"+                               , "Hash"+                               , "Hour"+                               , "HTMLCodeFormat"+                               , "HTMLEditFormat"+                               , "IIf"+                               , "IncrementValue"+                               , "InputBaseN"+                               , "Insert"+                               , "Int"+                               , "IsArray"+                               , "IsBinary"+                               , "IsBoolean"+                               , "IsCustomFunction"+                               , "IsDate"+                               , "IsDebugMode"+                               , "IsDefined"+                               , "IsK2ServerABroker"+                               , "IsK2ServerDocCountExceeded"+                               , "IsK2ServerOnline"+                               , "IsLeapYear"+                               , "IsNumeric"+                               , "IsNumericDate"+                               , "IsObject"+                               , "IsQuery"+                               , "IsSimpleValue"+                               , "IsStruct"+                               , "IsUserInRole"+                               , "IsWDDX"+                               , "IsXmlDoc"+                               , "IsXmlElement"+                               , "IsXmlRoot"+                               , "JavaCast"+                               , "JSStringFormat"+                               , "LCase"+                               , "Left"+                               , "Len"+                               , "ListAppend"+                               , "ListChangeDelims"+                               , "ListContains"+                               , "ListContainsNoCase"+                               , "ListDeleteAt"+                               , "ListFind"+                               , "ListFindNoCase"+                               , "ListFirst"+                               , "ListGetAt"+                               , "ListInsertAt"+                               , "ListLast"+                               , "ListLen"+                               , "ListPrepend"+                               , "ListQualify"+                               , "ListRest"+                               , "ListSetAt"+                               , "ListSort"+                               , "ListToArray"+                               , "ListValueCount"+                               , "ListValueCountNoCase"+                               , "LJustify"+                               , "Log"+                               , "Log10"+                               , "LSCurrencyFormat"+                               , "LSDateFormat"+                               , "LSEuroCurrencyFormat"+                               , "LSIsCurrency"+                               , "LSIsDate"+                               , "LSIsNumeric"+                               , "LSNumberFormat"+                               , "LSParseCurrency"+                               , "LSParseDateTime"+                               , "LSParseEuroCurrency"+                               , "LSParseNumber"+                               , "LSTimeFormat"+                               , "LTrim"+                               , "Max"+                               , "Mid"+                               , "Min"+                               , "Minute"+                               , "Month"+                               , "MonthAsString"+                               , "Now"+                               , "NumberFormat"+                               , "ParagraphFormat"+                               , "ParameterExists"+                               , "ParseDateTime"+                               , "Pi"+                               , "PreserveSingleQuotes"+                               , "Quarter"+                               , "QueryAddColumn"+                               , "QueryAddRow"+                               , "QueryNew"+                               , "QuerySetCell"+                               , "QuotedValueList"+                               , "Rand"+                               , "Randomize"+                               , "RandRange"+                               , "REFind"+                               , "REFindNoCase"+                               , "RemoveChars"+                               , "RepeatString"+                               , "Replace"+                               , "ReplaceList"+                               , "ReplaceNoCase"+                               , "REReplace"+                               , "REReplaceNoCase"+                               , "Reverse"+                               , "Right"+                               , "RJustify"+                               , "Round"+                               , "RTrim"+                               , "Second"+                               , "SetEncoding"+                               , "SetLocale"+                               , "SetProfileString"+                               , "SetVariable"+                               , "Sgn"+                               , "Sin"+                               , "SpanExcluding"+                               , "SpanIncluding"+                               , "Sqr"+                               , "StripCR"+                               , "StructAppend"+                               , "StructClear"+                               , "StructCopy"+                               , "StructCount"+                               , "StructDelete"+                               , "StructFind"+                               , "StructFindKey"+                               , "StructFindValue"+                               , "StructGet"+                               , "StructInsert"+                               , "StructIsEmpty"+                               , "StructKeyArray"+                               , "StructKeyExists"+                               , "StructKeyList"+                               , "StructNew"+                               , "StructSort"+                               , "StructUpdate"+                               , "Tan"+                               , "TimeFormat"+                               , "ToBase64"+                               , "ToBinary"+                               , "ToString"+                               , "Trim"+                               , "UCase"+                               , "URLDecode"+                               , "URLEncodedFormat"+                               , "URLSessionFormat"+                               , "Val"+                               , "ValueList"+                               , "Week"+                               , "WriteOutput"+                               , "XmlChildPos"+                               , "XmlElemNew"+                               , "XmlFormat"+                               , "XmlNew"+                               , "XmlParse"+                               , "XmlSearch"+                               , "XmlTransform"+                               , "Year"+                               , "YesNoFormat"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</[cC][fF][sS][cC][rR][iI][pP][tT]>"+                              , reCompiled =+                                  Just (compileRegex True "</[cC][fF][sS][cC][rR][iI][pP][tT]>")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ctxCFSCRIPT Tag"+          , Context+              { cName = "ctxCFSCRIPT Tag"+              , cSyntax = "ColdFusion"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ColdFusion" , "ctxCFSCRIPT Block" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"[^\"]*\""+                              , reCompiled = Just (compileRegex True "\"[^\"]*\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'[^']*'"+                              , reCompiled = Just (compileRegex True "'[^']*'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ctxCFX Tag"+          , Context+              { cName = "ctxCFX Tag"+              , cSyntax = "ColdFusion"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"[^\"]*\""+                              , reCompiled = Just (compileRegex True "\"[^\"]*\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'[^']*'"+                              , reCompiled = Just (compileRegex True "'[^']*'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ctxCustom Tag"+          , Context+              { cName = "ctxCustom Tag"+              , cSyntax = "ColdFusion"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"[^\"]*\""+                              , reCompiled = Just (compileRegex True "\"[^\"]*\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'[^']*'"+                              , reCompiled = Just (compileRegex True "'[^']*'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ctxHTML Comment"+          , Context+              { cName = "ctxHTML Comment"+              , cSyntax = "ColdFusion"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<!---"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ColdFusion" , "ctxCF Comment" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "-->"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ctxHTML Entities"+          , Context+              { cName = "ctxHTML Entities"+              , cSyntax = "ColdFusion"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ctxImage Tag"+          , Context+              { cName = "ctxImage Tag"+              , cSyntax = "ColdFusion"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"[^\"]*\""+                              , reCompiled = Just (compileRegex True "\"[^\"]*\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'[^']*'"+                              , reCompiled = Just (compileRegex True "'[^']*'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ctxOne Line Comment"+          , Context+              { cName = "ctxOne Line Comment"+              , cSyntax = "ColdFusion"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ctxSCRIPT Block"+          , Context+              { cName = "ctxSCRIPT Block"+              , cSyntax = "ColdFusion"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ColdFusion" , "ctxC Style Comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "ColdFusion" , "ctxOne Line Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"[^\"]*\""+                              , reCompiled = Just (compileRegex True "\"[^\"]*\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'[^']*'"+                              , reCompiled = Just (compileRegex True "'[^']*'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "[()[\\]=+-*/]+"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "{}"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "break"+                               , "case"+                               , "catch"+                               , "const"+                               , "continue"+                               , "default"+                               , "delete"+                               , "do"+                               , "else"+                               , "false"+                               , "for"+                               , "function"+                               , "if"+                               , "in"+                               , "new"+                               , "return"+                               , "switch"+                               , "this"+                               , "throw"+                               , "true"+                               , "try"+                               , "typeof"+                               , "var"+                               , "void"+                               , "while"+                               , "with"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "Anchor"+                               , "Applet"+                               , "Area"+                               , "Array"+                               , "Boolean"+                               , "Button"+                               , "Checkbox"+                               , "Date"+                               , "Document"+                               , "Event"+                               , "FileUpload"+                               , "Form"+                               , "Frame"+                               , "Function"+                               , "Hidden"+                               , "History"+                               , "Image"+                               , "Layer"+                               , "Linke"+                               , "Location"+                               , "Math"+                               , "Navigator"+                               , "Number"+                               , "Object"+                               , "Option"+                               , "Password"+                               , "Radio"+                               , "RegExp"+                               , "Reset"+                               , "Screen"+                               , "Select"+                               , "String"+                               , "Submit"+                               , "Text"+                               , "Textarea"+                               , "Window"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "abs"+                               , "acos"+                               , "alert"+                               , "anchor"+                               , "apply"+                               , "asin"+                               , "atan"+                               , "atan2"+                               , "back"+                               , "blur"+                               , "call"+                               , "captureEvents"+                               , "ceil"+                               , "charAt"+                               , "charCodeAt"+                               , "clearInterval"+                               , "clearTimeout"+                               , "click"+                               , "close"+                               , "compile"+                               , "concat"+                               , "confirm"+                               , "cos"+                               , "disableExternalCapture"+                               , "enableExternalCapture"+                               , "eval"+                               , "exec"+                               , "exp"+                               , "find"+                               , "floor"+                               , "focus"+                               , "forward"+                               , "fromCharCode"+                               , "getDate"+                               , "getDay"+                               , "getFullYear"+                               , "getHours"+                               , "getMilliseconds"+                               , "getMinutes"+                               , "getMonth"+                               , "getSeconds"+                               , "getSelection"+                               , "getTime"+                               , "getTimezoneOffset"+                               , "getUTCDate"+                               , "getUTCDay"+                               , "getUTCFullYear"+                               , "getUTCHours"+                               , "getUTCMilliseconds"+                               , "getUTCMinutes"+                               , "getUTCMonth"+                               , "getUTCSeconds"+                               , "go"+                               , "handleEvent"+                               , "home"+                               , "indexOf"+                               , "javaEnabled"+                               , "join"+                               , "lastIndexOf"+                               , "link"+                               , "load"+                               , "log"+                               , "match"+                               , "max"+                               , "min"+                               , "moveAbove"+                               , "moveBelow"+                               , "moveBy"+                               , "moveTo"+                               , "moveToAbsolute"+                               , "open"+                               , "parse"+                               , "plugins.refresh"+                               , "pop"+                               , "pow"+                               , "preference"+                               , "print"+                               , "prompt"+                               , "push"+                               , "random"+                               , "releaseEvents"+                               , "reload"+                               , "replace"+                               , "reset"+                               , "resizeBy"+                               , "resizeTo"+                               , "reverse"+                               , "round"+                               , "routeEvent"+                               , "scrollBy"+                               , "scrollTo"+                               , "search"+                               , "select"+                               , "setDate"+                               , "setFullYear"+                               , "setHours"+                               , "setInterval"+                               , "setMilliseconds"+                               , "setMinutes"+                               , "setMonth"+                               , "setSeconds"+                               , "setTime"+                               , "setTimeout"+                               , "setUTCDate"+                               , "setUTCFullYear"+                               , "setUTCHours"+                               , "setUTCMilliseconds"+                               , "setUTCMinutes"+                               , "setUTCMonth"+                               , "setUTCSeconds"+                               , "shift"+                               , "sin"+                               , "slice"+                               , "sort"+                               , "splice"+                               , "split"+                               , "sqrt"+                               , "stop"+                               , "String formatting"+                               , "submit"+                               , "substr"+                               , "substring"+                               , "taintEnabled"+                               , "tan"+                               , "test"+                               , "toLocaleString"+                               , "toLowerCase"+                               , "toSource"+                               , "toString"+                               , "toUpperCase"+                               , "toUTCString"+                               , "unshift"+                               , "unwatch"+                               , "UTC"+                               , "valueOf"+                               , "watch"+                               , "write"+                               , "writeln"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</[sS][cC][rR][iI][pP][tT]>"+                              , reCompiled =+                                  Just (compileRegex True "</[sS][cC][rR][iI][pP][tT]>")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ctxSCRIPT Tag"+          , Context+              { cName = "ctxSCRIPT Tag"+              , cSyntax = "ColdFusion"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ColdFusion" , "ctxSCRIPT Block" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"[^\"]*\""+                              , reCompiled = Just (compileRegex True "\"[^\"]*\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'[^']*'"+                              , reCompiled = Just (compileRegex True "'[^']*'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ctxSTYLE Block"+          , Context+              { cName = "ctxSTYLE Block"+              , cSyntax = "ColdFusion"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ColdFusion" , "ctxC Style Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "ColdFusion" , "ctxStyle Properties" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</[sS][tT][yY][lL][eE]>"+                              , reCompiled = Just (compileRegex True "</[sS][tT][yY][lL][eE]>")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ctxSTYLE Tag"+          , Context+              { cName = "ctxSTYLE Tag"+              , cSyntax = "ColdFusion"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ColdFusion" , "ctxSTYLE Block" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"[^\"]*\""+                              , reCompiled = Just (compileRegex True "\"[^\"]*\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'[^']*'"+                              , reCompiled = Just (compileRegex True "'[^']*'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ctxStyle Properties"+          , Context+              { cName = "ctxStyle Properties"+              , cSyntax = "ColdFusion"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ColdFusion" , "ctxC Style Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ColdFusion" , "ctxStyle Values" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ctxStyle Values"+          , Context+              { cName = "ctxStyle Values"+              , cSyntax = "ColdFusion"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#([0-9a-fA-F]{3})|([0-9a-fA-F]{6})"+                              , reCompiled =+                                  Just (compileRegex True "#([0-9a-fA-F]{3})|([0-9a-fA-F]{6})")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"[^\"]*\""+                              , reCompiled = Just (compileRegex True "\"[^\"]*\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'[^']*'"+                              , reCompiled = Just (compileRegex True "'[^']*'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ctxTable Tag"+          , Context+              { cName = "ctxTable Tag"+              , cSyntax = "ColdFusion"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"[^\"]*\""+                              , reCompiled = Just (compileRegex True "\"[^\"]*\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'[^']*'"+                              , reCompiled = Just (compileRegex True "'[^']*'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ctxTag"+          , Context+              { cName = "ctxTag"+              , cSyntax = "ColdFusion"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"[^\"]*\""+                              , reCompiled = Just (compileRegex True "\"[^\"]*\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'[^']*'"+                              , reCompiled = Just (compileRegex True "'[^']*'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = ""+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.cfm" , "*.cfc" , "*.cfml" , "*.dbm" ]+  , sStartingContext = "Normal Text"+  }
+ src/Skylighting/Syntax/Commonlisp.hs view
@@ -0,0 +1,1585 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Commonlisp (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Common Lisp"+  , sFilename = "commonlisp.xml"+  , sShortname = "Commonlisp"+  , sContexts =+      fromList+        [ ( "MultiLineComment"+          , Context+              { cName = "MultiLineComment"+              , cSyntax = "Common Lisp"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '|' '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Common Lisp"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ";+\\s*BEGIN.*$"+                              , reCompiled = Just (compileRegex True ";+\\s*BEGIN.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ";+\\s*END.*$"+                              , reCompiled = Just (compileRegex True ";+\\s*END.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ";.*$"+                              , reCompiled = Just (compileRegex True ";.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '|'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Common Lisp" , "MultiLineComment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&(),.;[]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "abort"+                               , "abs"+                               , "access"+                               , "acons"+                               , "acos"+                               , "acosh"+                               , "add-method"+                               , "adjoin"+                               , "adjust-array"+                               , "adjustable-array-p"+                               , "allocate-instance"+                               , "alpha-char-p"+                               , "alphanumericp"+                               , "and"+                               , "append"+                               , "apply"+                               , "applyhook"+                               , "apropos"+                               , "apropos-list"+                               , "aref"+                               , "arithmetic-error"+                               , "arithmetic-error-operands"+                               , "arithmetic-error-operation"+                               , "array"+                               , "array-dimension"+                               , "array-dimension-limit"+                               , "array-dimensions"+                               , "array-displacement"+                               , "array-element-type"+                               , "array-has-fill-pointer-p"+                               , "array-in-bounds-p"+                               , "array-rank"+                               , "array-rank-limit"+                               , "array-row-major-index"+                               , "array-total-size"+                               , "array-total-size-limit"+                               , "arrayp"+                               , "ash"+                               , "asin"+                               , "asinh"+                               , "assert"+                               , "assoc"+                               , "assoc-if"+                               , "assoc-if-not"+                               , "atan"+                               , "atanh"+                               , "atom"+                               , "base-char"+                               , "base-string"+                               , "bignum"+                               , "bit"+                               , "bit-and"+                               , "bit-andc1"+                               , "bit-andc2"+                               , "bit-eqv"+                               , "bit-ior"+                               , "bit-nand"+                               , "bit-nor"+                               , "bit-not"+                               , "bit-orc1"+                               , "bit-orc2"+                               , "bit-vector"+                               , "bit-vector-p"+                               , "bit-xor"+                               , "block"+                               , "boole"+                               , "boole-1"+                               , "boole-2"+                               , "boole-and"+                               , "boole-andc1"+                               , "boole-andc2"+                               , "boole-c1"+                               , "boole-c2"+                               , "boole-clr"+                               , "boole-eqv"+                               , "boole-ior"+                               , "boole-nand"+                               , "boole-nor"+                               , "boole-orc1"+                               , "boole-orc2"+                               , "boole-set"+                               , "boole-xor"+                               , "boolean"+                               , "both-case-p"+                               , "boundp"+                               , "break"+                               , "broadcast-stream"+                               , "broadcast-stream-streams"+                               , "built-in-class"+                               , "butlast"+                               , "byte"+                               , "byte-position"+                               , "byte-size"+                               , "caaaar"+                               , "caaadr"+                               , "caaar"+                               , "caadar"+                               , "caaddr"+                               , "caadr"+                               , "caar"+                               , "cadaar"+                               , "cadadr"+                               , "cadar"+                               , "caddar"+                               , "cadddr"+                               , "caddr"+                               , "cadr"+                               , "call-arguments-limit"+                               , "call-method"+                               , "call-next-method"+                               , "capitalize"+                               , "car"+                               , "case"+                               , "catch"+                               , "ccase"+                               , "cdaaar"+                               , "cdaadr"+                               , "cdaar"+                               , "cdadar"+                               , "cdaddr"+                               , "cdadr"+                               , "cdar"+                               , "cddaar"+                               , "cddadr"+                               , "cddar"+                               , "cdddar"+                               , "cddddr"+                               , "cdddr"+                               , "cddr"+                               , "cdr"+                               , "ceiling"+                               , "cell-error"+                               , "cell-error-name"+                               , "cerror"+                               , "change-class"+                               , "char"+                               , "char-bit"+                               , "char-bits"+                               , "char-bits-limit"+                               , "char-code"+                               , "char-code-limit"+                               , "char-control-bit"+                               , "char-downcase"+                               , "char-equal"+                               , "char-font"+                               , "char-font-limit"+                               , "char-greaterp"+                               , "char-hyper-bit"+                               , "char-int"+                               , "char-lessp"+                               , "char-meta-bit"+                               , "char-name"+                               , "char-not-equal"+                               , "char-not-greaterp"+                               , "char-not-lessp"+                               , "char-super-bit"+                               , "char-upcase"+                               , "char/="+                               , "char<"+                               , "char<="+                               , "char="+                               , "char>"+                               , "char>="+                               , "character"+                               , "characterp"+                               , "check-type"+                               , "cis"+                               , "class"+                               , "class-name"+                               , "class-of"+                               , "clear-input"+                               , "clear-output"+                               , "close"+                               , "clrhash"+                               , "code-char"+                               , "coerce"+                               , "commonp"+                               , "compilation-speed"+                               , "compile"+                               , "compile-file"+                               , "compile-file-pathname"+                               , "compiled-function"+                               , "compiled-function-p"+                               , "compiler-let"+                               , "compiler-macro"+                               , "compiler-macro-function"+                               , "complement"+                               , "complex"+                               , "complexp"+                               , "compute-applicable-methods"+                               , "compute-restarts"+                               , "concatenate"+                               , "concatenated-stream"+                               , "concatenated-stream-streams"+                               , "cond"+                               , "condition"+                               , "conjugate"+                               , "cons"+                               , "consp"+                               , "constantly"+                               , "constantp"+                               , "continue"+                               , "control-error"+                               , "copy-alist"+                               , "copy-list"+                               , "copy-pprint-dispatch"+                               , "copy-readtable"+                               , "copy-seq"+                               , "copy-structure"+                               , "copy-symbol"+                               , "copy-tree"+                               , "cos"+                               , "cosh"+                               , "count"+                               , "count-if"+                               , "count-if-not"+                               , "ctypecase"+                               , "debug"+                               , "decf"+                               , "declaim"+                               , "declaration"+                               , "declare"+                               , "decode-float"+                               , "decode-universal-time"+                               , "delete"+                               , "delete-duplicates"+                               , "delete-file"+                               , "delete-if"+                               , "delete-if-not"+                               , "delete-package"+                               , "denominator"+                               , "deposit-field"+                               , "describe"+                               , "describe-object"+                               , "destructuring-bind"+                               , "digit-char"+                               , "digit-char-p"+                               , "directory"+                               , "directory-namestring"+                               , "disassemble"+                               , "division-by-zero"+                               , "do"+                               , "do*"+                               , "do-all-symbols"+                               , "do-exeternal-symbols"+                               , "do-external-symbols"+                               , "do-symbols"+                               , "documentation"+                               , "dolist"+                               , "dotimes"+                               , "double-float"+                               , "double-float-epsilon"+                               , "double-float-negative-epsilon"+                               , "dpb"+                               , "dribble"+                               , "dynamic-extent"+                               , "ecase"+                               , "echo-stream"+                               , "echo-stream-input-stream"+                               , "echo-stream-output-stream"+                               , "ed"+                               , "eighth"+                               , "elt"+                               , "encode-universal-time"+                               , "end-of-file"+                               , "endp"+                               , "enough-namestring"+                               , "ensure-directories-exist"+                               , "ensure-generic-function"+                               , "eq"+                               , "eql"+                               , "equal"+                               , "equalp"+                               , "error"+                               , "etypecase"+                               , "eval"+                               , "eval-when"+                               , "evalhook"+                               , "evenp"+                               , "every"+                               , "exp"+                               , "export"+                               , "expt"+                               , "extended-char"+                               , "fboundp"+                               , "fceiling"+                               , "fdefinition"+                               , "ffloor"+                               , "fifth"+                               , "file-author"+                               , "file-error"+                               , "file-error-pathname"+                               , "file-length"+                               , "file-namestring"+                               , "file-position"+                               , "file-stream"+                               , "file-string-length"+                               , "file-write-date"+                               , "fill"+                               , "fill-pointer"+                               , "find"+                               , "find-all-symbols"+                               , "find-class"+                               , "find-if"+                               , "find-if-not"+                               , "find-method"+                               , "find-package"+                               , "find-restart"+                               , "find-symbol"+                               , "finish-output"+                               , "first"+                               , "fixnum"+                               , "flet"+                               , "float"+                               , "float-digits"+                               , "float-precision"+                               , "float-radix"+                               , "float-sign"+                               , "floating-point-inexact"+                               , "floating-point-invalid-operation"+                               , "floating-point-overflow"+                               , "floating-point-underflow"+                               , "floatp"+                               , "floor"+                               , "fmakunbound"+                               , "force-output"+                               , "format"+                               , "formatter"+                               , "fourth"+                               , "fresh-line"+                               , "fround"+                               , "ftruncate"+                               , "ftype"+                               , "funcall"+                               , "function"+                               , "function-keywords"+                               , "function-lambda-expression"+                               , "functionp"+                               , "gbitp"+                               , "gcd"+                               , "generic-function"+                               , "gensym"+                               , "gentemp"+                               , "get"+                               , "get-decoded-time"+                               , "get-dispatch-macro-character"+                               , "get-internal-real-time"+                               , "get-internal-run-time"+                               , "get-macro-character"+                               , "get-output-stream-string"+                               , "get-properties"+                               , "get-setf-expansion"+                               , "get-setf-method"+                               , "get-universal-time"+                               , "getf"+                               , "gethash"+                               , "go"+                               , "graphic-char-p"+                               , "handler-bind"+                               , "handler-case"+                               , "hash-table"+                               , "hash-table-count"+                               , "hash-table-p"+                               , "hash-table-rehash-size"+                               , "hash-table-rehash-threshold"+                               , "hash-table-size"+                               , "hash-table-test"+                               , "host-namestring"+                               , "identity"+                               , "if"+                               , "if-exists"+                               , "ignorable"+                               , "ignore"+                               , "ignore-errors"+                               , "imagpart"+                               , "import"+                               , "in-package"+                               , "incf"+                               , "initialize-instance"+                               , "inline"+                               , "input-stream-p"+                               , "inspect"+                               , "int-char"+                               , "integer"+                               , "integer-decode-float"+                               , "integer-length"+                               , "integerp"+                               , "interactive-stream-p"+                               , "intern"+                               , "internal-time-units-per-second"+                               , "intersection"+                               , "invalid-method-error"+                               , "invoke-debugger"+                               , "invoke-restart"+                               , "invoke-restart-interactively"+                               , "isqrt"+                               , "keyword"+                               , "keywordp"+                               , "labels"+                               , "lambda"+                               , "lambda-list-keywords"+                               , "lambda-parameters-limit"+                               , "last"+                               , "lcm"+                               , "ldb"+                               , "ldb-test"+                               , "ldiff"+                               , "least-negative-double-float"+                               , "least-negative-long-float"+                               , "least-negative-normalized-double-float"+                               , "least-negative-normalized-long-float"+                               , "least-negative-normalized-short-float"+                               , "least-negative-normalized-single-float"+                               , "least-negative-short-float"+                               , "least-negative-single-float"+                               , "least-positive-double-float"+                               , "least-positive-long-float"+                               , "least-positive-normalized-double-float"+                               , "least-positive-normalized-long-float"+                               , "least-positive-normalized-short-float"+                               , "least-positive-normalized-single-float"+                               , "least-positive-short-float"+                               , "least-positive-single-float"+                               , "length"+                               , "let"+                               , "let*"+                               , "lisp"+                               , "lisp-implementation-type"+                               , "lisp-implementation-version"+                               , "list"+                               , "list*"+                               , "list-all-packages"+                               , "list-length"+                               , "listen"+                               , "listp"+                               , "load"+                               , "load-logical-pathname-translations"+                               , "load-time-value"+                               , "locally"+                               , "log"+                               , "logand"+                               , "logandc1"+                               , "logandc2"+                               , "logbitp"+                               , "logcount"+                               , "logeqv"+                               , "logical-pathname"+                               , "logical-pathname-translations"+                               , "logior"+                               , "lognand"+                               , "lognor"+                               , "lognot"+                               , "logorc1"+                               , "logorc2"+                               , "logtest"+                               , "logxor"+                               , "long-float"+                               , "long-float-epsilon"+                               , "long-float-negative-epsilon"+                               , "long-site-name"+                               , "loop"+                               , "loop-finish"+                               , "lower-case-p"+                               , "machine-instance"+                               , "machine-type"+                               , "machine-version"+                               , "macro-function"+                               , "macroexpand"+                               , "macroexpand-1"+                               , "macroexpand-l"+                               , "macrolet"+                               , "make-array"+                               , "make-broadcast-stream"+                               , "make-char"+                               , "make-concatenated-stream"+                               , "make-condition"+                               , "make-dispatch-macro-character"+                               , "make-echo-stream"+                               , "make-hash-table"+                               , "make-instance"+                               , "make-instances-obsolete"+                               , "make-list"+                               , "make-load-form"+                               , "make-load-form-saving-slots"+                               , "make-method"+                               , "make-package"+                               , "make-pathname"+                               , "make-random-state"+                               , "make-sequence"+                               , "make-string"+                               , "make-string-input-stream"+                               , "make-string-output-stream"+                               , "make-symbol"+                               , "make-synonym-stream"+                               , "make-two-way-stream"+                               , "makunbound"+                               , "map"+                               , "map-into"+                               , "mapc"+                               , "mapcan"+                               , "mapcar"+                               , "mapcon"+                               , "maphash"+                               , "mapl"+                               , "maplist"+                               , "mask-field"+                               , "max"+                               , "member"+                               , "member-if"+                               , "member-if-not"+                               , "merge"+                               , "merge-pathname"+                               , "merge-pathnames"+                               , "method"+                               , "method-combination"+                               , "method-combination-error"+                               , "method-qualifiers"+                               , "min"+                               , "minusp"+                               , "mismatch"+                               , "mod"+                               , "most-negative-double-float"+                               , "most-negative-fixnum"+                               , "most-negative-long-float"+                               , "most-negative-short-float"+                               , "most-negative-single-float"+                               , "most-positive-double-float"+                               , "most-positive-fixnum"+                               , "most-positive-long-float"+                               , "most-positive-short-float"+                               , "most-positive-single-float"+                               , "muffle-warning"+                               , "multiple-value-bind"+                               , "multiple-value-call"+                               , "multiple-value-list"+                               , "multiple-value-prog1"+                               , "multiple-value-seteq"+                               , "multiple-value-setq"+                               , "multiple-values-limit"+                               , "name-char"+                               , "namestring"+                               , "nbutlast"+                               , "nconc"+                               , "next-method-p"+                               , "nil"+                               , "nintersection"+                               , "ninth"+                               , "no-applicable-method"+                               , "no-next-method"+                               , "not"+                               , "notany"+                               , "notevery"+                               , "notinline"+                               , "nreconc"+                               , "nreverse"+                               , "nset-difference"+                               , "nset-exclusive-or"+                               , "nstring"+                               , "nstring-capitalize"+                               , "nstring-downcase"+                               , "nstring-upcase"+                               , "nsublis"+                               , "nsubst"+                               , "nsubst-if"+                               , "nsubst-if-not"+                               , "nsubstitute"+                               , "nsubstitute-if"+                               , "nsubstitute-if-not"+                               , "nth"+                               , "nth-value"+                               , "nthcdr"+                               , "null"+                               , "number"+                               , "numberp"+                               , "numerator"+                               , "nunion"+                               , "oddp"+                               , "open"+                               , "open-stream-p"+                               , "optimize"+                               , "or"+                               , "otherwise"+                               , "output-stream-p"+                               , "package"+                               , "package-error"+                               , "package-error-package"+                               , "package-name"+                               , "package-nicknames"+                               , "package-shadowing-symbols"+                               , "package-use-list"+                               , "package-used-by-list"+                               , "packagep"+                               , "pairlis"+                               , "parse-error"+                               , "parse-integer"+                               , "parse-namestring"+                               , "pathname"+                               , "pathname-device"+                               , "pathname-directory"+                               , "pathname-host"+                               , "pathname-match-p"+                               , "pathname-name"+                               , "pathname-type"+                               , "pathname-version"+                               , "pathnamep"+                               , "peek-char"+                               , "phase"+                               , "pi"+                               , "plusp"+                               , "pop"+                               , "position"+                               , "position-if"+                               , "position-if-not"+                               , "pprint"+                               , "pprint-dispatch"+                               , "pprint-exit-if-list-exhausted"+                               , "pprint-fill"+                               , "pprint-indent"+                               , "pprint-linear"+                               , "pprint-logical-block"+                               , "pprint-newline"+                               , "pprint-pop"+                               , "pprint-tab"+                               , "pprint-tabular"+                               , "prin1"+                               , "prin1-to-string"+                               , "princ"+                               , "princ-to-string"+                               , "print"+                               , "print-not-readable"+                               , "print-not-readable-object"+                               , "print-object"+                               , "print-unreadable-object"+                               , "probe-file"+                               , "proclaim"+                               , "prog"+                               , "prog*"+                               , "prog1"+                               , "prog2"+                               , "progn"+                               , "program-error"+                               , "progv"+                               , "provide"+                               , "psetf"+                               , "psetq"+                               , "push"+                               , "pushnew"+                               , "putprop"+                               , "quote"+                               , "random"+                               , "random-state"+                               , "random-state-p"+                               , "rassoc"+                               , "rassoc-if"+                               , "rassoc-if-not"+                               , "ratio"+                               , "rational"+                               , "rationalize"+                               , "rationalp"+                               , "read"+                               , "read-byte"+                               , "read-char"+                               , "read-char-no-hang"+                               , "read-delimited-list"+                               , "read-eval-print"+                               , "read-from-string"+                               , "read-line"+                               , "read-preserving-whitespace"+                               , "read-sequence"+                               , "reader-error"+                               , "readtable"+                               , "readtable-case"+                               , "readtablep"+                               , "real"+                               , "realp"+                               , "realpart"+                               , "reduce"+                               , "reinitialize-instance"+                               , "rem"+                               , "remf"+                               , "remhash"+                               , "remove"+                               , "remove-duplicates"+                               , "remove-if"+                               , "remove-if-not"+                               , "remove-method"+                               , "remprop"+                               , "rename-file"+                               , "rename-package"+                               , "replace"+                               , "require"+                               , "rest"+                               , "restart"+                               , "restart-bind"+                               , "restart-case"+                               , "restart-name"+                               , "return"+                               , "return-from"+                               , "revappend"+                               , "reverse"+                               , "room"+                               , "rotatef"+                               , "round"+                               , "row-major-aref"+                               , "rplaca"+                               , "rplacd"+                               , "safety"+                               , "satisfies"+                               , "sbit"+                               , "scale-float"+                               , "schar"+                               , "search"+                               , "second"+                               , "sequence"+                               , "serious-condition"+                               , "set"+                               , "set-char-bit"+                               , "set-difference"+                               , "set-dispatch-macro-character"+                               , "set-exclusive-or"+                               , "set-macro-character"+                               , "set-pprint-dispatch"+                               , "set-syntax-from-char"+                               , "setf"+                               , "setq"+                               , "seventh"+                               , "shadow"+                               , "shadowing-import"+                               , "shared-initialize"+                               , "shiftf"+                               , "short-float"+                               , "short-float-epsilon"+                               , "short-float-negative-epsilon"+                               , "short-site-name"+                               , "signal"+                               , "signed-byte"+                               , "signum"+                               , "simle-condition"+                               , "simple-array"+                               , "simple-base-string"+                               , "simple-bit-vector"+                               , "simple-bit-vector-p"+                               , "simple-condition-format-arguments"+                               , "simple-condition-format-control"+                               , "simple-error"+                               , "simple-string"+                               , "simple-string-p"+                               , "simple-type-error"+                               , "simple-vector"+                               , "simple-vector-p"+                               , "simple-warning"+                               , "sin"+                               , "single-flaot-epsilon"+                               , "single-float"+                               , "single-float-epsilon"+                               , "single-float-negative-epsilon"+                               , "sinh"+                               , "sixth"+                               , "sleep"+                               , "slot-boundp"+                               , "slot-exists-p"+                               , "slot-makunbound"+                               , "slot-missing"+                               , "slot-unbound"+                               , "slot-value"+                               , "software-type"+                               , "software-version"+                               , "some"+                               , "sort"+                               , "space"+                               , "special"+                               , "special-form-p"+                               , "special-operator-p"+                               , "speed"+                               , "sqrt"+                               , "stable-sort"+                               , "standard"+                               , "standard-char"+                               , "standard-char-p"+                               , "standard-class"+                               , "standard-generic-function"+                               , "standard-method"+                               , "standard-object"+                               , "step"+                               , "storage-condition"+                               , "store-value"+                               , "stream"+                               , "stream-element-type"+                               , "stream-error"+                               , "stream-error-stream"+                               , "stream-external-format"+                               , "streamp"+                               , "streamup"+                               , "string"+                               , "string-capitalize"+                               , "string-char"+                               , "string-char-p"+                               , "string-downcase"+                               , "string-equal"+                               , "string-greaterp"+                               , "string-left-trim"+                               , "string-lessp"+                               , "string-not-equal"+                               , "string-not-greaterp"+                               , "string-not-lessp"+                               , "string-right-strim"+                               , "string-right-trim"+                               , "string-stream"+                               , "string-trim"+                               , "string-upcase"+                               , "string/="+                               , "string<"+                               , "string<="+                               , "string="+                               , "string>"+                               , "string>="+                               , "stringp"+                               , "structure"+                               , "structure-class"+                               , "structure-object"+                               , "style-warning"+                               , "sublim"+                               , "sublis"+                               , "subseq"+                               , "subsetp"+                               , "subst"+                               , "subst-if"+                               , "subst-if-not"+                               , "substitute"+                               , "substitute-if"+                               , "substitute-if-not"+                               , "subtypep"+                               , "svref"+                               , "sxhash"+                               , "symbol"+                               , "symbol-function"+                               , "symbol-macrolet"+                               , "symbol-name"+                               , "symbol-package"+                               , "symbol-plist"+                               , "symbol-value"+                               , "symbolp"+                               , "synonym-stream"+                               , "synonym-stream-symbol"+                               , "sys"+                               , "system"+                               , "t"+                               , "tagbody"+                               , "tailp"+                               , "tan"+                               , "tanh"+                               , "tenth"+                               , "terpri"+                               , "the"+                               , "third"+                               , "throw"+                               , "time"+                               , "trace"+                               , "translate-logical-pathname"+                               , "translate-pathname"+                               , "tree-equal"+                               , "truename"+                               , "truncase"+                               , "truncate"+                               , "two-way-stream"+                               , "two-way-stream-input-stream"+                               , "two-way-stream-output-stream"+                               , "type"+                               , "type-error"+                               , "type-error-datum"+                               , "type-error-expected-type"+                               , "type-of"+                               , "typecase"+                               , "typep"+                               , "unbound-slot"+                               , "unbound-slot-instance"+                               , "unbound-variable"+                               , "undefined-function"+                               , "unexport"+                               , "unintern"+                               , "union"+                               , "unless"+                               , "unread"+                               , "unread-char"+                               , "unsigned-byte"+                               , "untrace"+                               , "unuse-package"+                               , "unwind-protect"+                               , "update-instance-for-different-class"+                               , "update-instance-for-redefined-class"+                               , "upgraded-array-element-type"+                               , "upgraded-complex-part-type"+                               , "upper-case-p"+                               , "use-package"+                               , "use-value"+                               , "user"+                               , "user-homedir-pathname"+                               , "values"+                               , "values-list"+                               , "vector"+                               , "vector-pop"+                               , "vector-push"+                               , "vector-push-extend"+                               , "vectorp"+                               , "warn"+                               , "warning"+                               , "when"+                               , "wild-pathname-p"+                               , "with-accessors"+                               , "with-compilation-unit"+                               , "with-condition-restarts"+                               , "with-hash-table-iterator"+                               , "with-input-from-string"+                               , "with-open-file"+                               , "with-open-stream"+                               , "with-output-to-string"+                               , "with-package-iterator"+                               , "with-simple-restart"+                               , "with-slots"+                               , "with-standard-io-syntax"+                               , "write"+                               , "write-byte"+                               , "write-char"+                               , "write-line"+                               , "write-sequence"+                               , "write-string"+                               , "write-to-string"+                               , "y-or-n-p"+                               , "yes-or-no-p"+                               , "zerop"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&(),.;[]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "*"+                               , "**"+                               , "***"+                               , "+"+                               , "++"+                               , "+++"+                               , "-"+                               , "/"+                               , "//"+                               , "///"+                               , "/="+                               , "1+"+                               , "1-"+                               , "<"+                               , "<="+                               , "="+                               , "=>"+                               , ">"+                               , ">="+                               ])+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&(),.;[]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ ":abort"+                               , ":adjustable"+                               , ":append"+                               , ":array"+                               , ":base"+                               , ":case"+                               , ":circle"+                               , ":conc-name"+                               , ":constructor"+                               , ":copier"+                               , ":count"+                               , ":create"+                               , ":default"+                               , ":defaults"+                               , ":device"+                               , ":direction"+                               , ":directory"+                               , ":displaced-index-offset"+                               , ":displaced-to"+                               , ":element-type"+                               , ":end"+                               , ":end1"+                               , ":end2"+                               , ":error"+                               , ":escape"+                               , ":external"+                               , ":from-end"+                               , ":gensym"+                               , ":host"+                               , ":if-does-not-exist:pretty"+                               , ":if-exists:print"+                               , ":include:print-function"+                               , ":index"+                               , ":inherited"+                               , ":initial-contents"+                               , ":initial-element"+                               , ":initial-offset"+                               , ":initial-value"+                               , ":input"+                               , ":internal:size"+                               , ":io"+                               , ":junk-allowed"+                               , ":key"+                               , ":length"+                               , ":level"+                               , ":name"+                               , ":named"+                               , ":new-version"+                               , ":nicknames"+                               , ":output"+                               , ":output-file"+                               , ":overwrite"+                               , ":predicate"+                               , ":preserve-whitespace"+                               , ":probe"+                               , ":radix"+                               , ":read-only"+                               , ":rehash-size"+                               , ":rehash-threshold"+                               , ":rename"+                               , ":rename-and-delete"+                               , ":start"+                               , ":start1"+                               , ":start2"+                               , ":stream"+                               , ":supersede"+                               , ":test"+                               , ":test-not"+                               , ":type"+                               , ":use"+                               , ":verbose"+                               , ":version"+                               ])+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&(),.;[]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "*applyhook*"+                               , "*break-on-signals*"+                               , "*break-on-warnings*"+                               , "*compile-file-pathname*"+                               , "*compile-file-truename*"+                               , "*compile-print*"+                               , "*compile-verbose*"+                               , "*debug-io*"+                               , "*debugger-hook*"+                               , "*default-pathname-defaults*"+                               , "*error-output*"+                               , "*evalhook*"+                               , "*features*"+                               , "*gensym-counter*"+                               , "*load-pathname*"+                               , "*load-print*"+                               , "*load-truename*"+                               , "*load-verbose*"+                               , "*macroexpand-hook*"+                               , "*modules*"+                               , "*package*"+                               , "*print-array*"+                               , "*print-base*"+                               , "*print-case*"+                               , "*print-circle*"+                               , "*print-escape*"+                               , "*print-gensym*"+                               , "*print-length*"+                               , "*print-level*"+                               , "*print-lines*"+                               , "*print-miser-width*"+                               , "*print-pprint-dispatch*"+                               , "*print-pretty*"+                               , "*print-radix*"+                               , "*print-readably*"+                               , "*print-right-margin*"+                               , "*query-io*"+                               , "*random-state*"+                               , "*read-base*"+                               , "*read-default-float-format*"+                               , "*read-eval*"+                               , "*read-suppress*"+                               , "*readtable*"+                               , "*standard-input*"+                               , "*standard-output*"+                               , "*terminal-io*"+                               , "*trace-output*"+                               ])+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&(),.;[]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "defclass"+                               , "defconstant"+                               , "defgeneric"+                               , "define-compiler-macro"+                               , "define-condition"+                               , "define-method-combination"+                               , "define-modify-macro"+                               , "define-setf-expander"+                               , "define-setf-method"+                               , "define-symbol-macro"+                               , "defmacro"+                               , "defmethod"+                               , "defpackage"+                               , "defparameter"+                               , "defsetf"+                               , "defstruct"+                               , "deftype"+                               , "defun"+                               , "defvar"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Common Lisp" , "function_decl" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\\\."+                              , reCompiled = Just (compileRegex True "#\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Common Lisp" , "String" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#[bodxei]"+                              , reCompiled = Just (compileRegex True "#[bodxei]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Common Lisp" , "SpecialNumber" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#[tf]"+                              , reCompiled = Just (compileRegex True "#[tf]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SpecialNumber"+          , Context+              { cName = "SpecialNumber"+              , cSyntax = "Common Lisp"+              , cRules =+                  [ Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Common Lisp"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\\\."+                              , reCompiled = Just (compileRegex True "#\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "function_decl"+          , Context+              { cName = "function_decl"+              , cSyntax = "Common Lisp"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*[A-Za-z0-9-+\\<\\>//\\*]*\\s*"+                              , reCompiled =+                                  Just (compileRegex True "\\s*[A-Za-z0-9-+\\<\\>//\\*]*\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Dominik Haumann (dhdev@gmx.de)"+  , sVersion = "3"+  , sLicense = "LGPLv2+"+  , sExtensions = [ "*.lisp" , "*.cl" , "*.lsp" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Cpp.hs view
@@ -0,0 +1,1718 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Cpp (syntax) where++import Skylighting.Types+import Data.Map+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "C++"+  , sFilename = "cpp.xml"+  , sShortname = "Cpp"+  , sContexts =+      fromList+        [ ( "DetectNSEnd"+          , Context+              { cName = "DetectNSEnd"+              , cSyntax = "C++"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "!% &()+-/.*<=>?[]{|}~^,;"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = AnyChar " "+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DetectQt4Extensions"+          , Context+              { cName = "DetectQt4Extensions"+              , cSyntax = "C++"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "QObjectList"+                               , "QRgb"+                               , "Q_PID"+                               , "QtMsgHandler"+                               , "QtMsgType"+                               , "WId"+                               , "qScriptConnect"+                               , "qScriptDisconnect"+                               , "qScriptRegisterMetaType"+                               , "qScriptRegisterSequenceMetaType"+                               , "qScriptValueFromSequence"+                               , "qScriptValueToSequence"+                               , "qint16"+                               , "qint32"+                               , "qint64"+                               , "qint8"+                               , "qlonglong"+                               , "qptrdiff"+                               , "qreal"+                               , "quint16"+                               , "quint32"+                               , "quint64"+                               , "quint8"+                               , "quintptr"+                               , "qulonglong"+                               , "uchar"+                               , "uint"+                               , "ulong"+                               , "ushort"+                               ])+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Phonon"+                               , "QAbstractAnimation"+                               , "QAbstractButton"+                               , "QAbstractEventDispatcher"+                               , "QAbstractExtensionFactory"+                               , "QAbstractExtensionManager"+                               , "QAbstractFileEngine"+                               , "QAbstractFileEngineHandler"+                               , "QAbstractFileEngineIterator"+                               , "QAbstractFontEngine"+                               , "QAbstractFormBuilder"+                               , "QAbstractGraphicsShapeItem"+                               , "QAbstractItemDelegate"+                               , "QAbstractItemModel"+                               , "QAbstractItemView"+                               , "QAbstractListModel"+                               , "QAbstractMessageHandler"+                               , "QAbstractNetworkCache"+                               , "QAbstractPrintDialog"+                               , "QAbstractProxyModel"+                               , "QAbstractScrollArea"+                               , "QAbstractSlider"+                               , "QAbstractSocket"+                               , "QAbstractSpinBox"+                               , "QAbstractState"+                               , "QAbstractTableModel"+                               , "QAbstractTextDocumentLayout"+                               , "QAbstractTransition"+                               , "QAbstractUriResolver"+                               , "QAbstractVideoBuffer"+                               , "QAbstractVideoSurface"+                               , "QAbstractXmlNodeModel"+                               , "QAbstractXmlReceiver"+                               , "QAccessible"+                               , "QAccessibleBridge"+                               , "QAccessibleBridgePlugin"+                               , "QAccessibleEvent"+                               , "QAccessibleInterface"+                               , "QAccessibleObject"+                               , "QAccessiblePlugin"+                               , "QAccessibleWidget"+                               , "QAction"+                               , "QActionEvent"+                               , "QActionGroup"+                               , "QAnimationGroup"+                               , "QApplication"+                               , "QAtomicInt"+                               , "QAtomicPointer"+                               , "QAudioDeviceInfo"+                               , "QAudioFormat"+                               , "QAudioInput"+                               , "QAudioOutput"+                               , "QAuthenticator"+                               , "QAxAggregated"+                               , "QAxBase"+                               , "QAxBindable"+                               , "QAxFactory"+                               , "QAxObject"+                               , "QAxScript"+                               , "QAxScriptEngine"+                               , "QAxScriptManager"+                               , "QAxWidget"+                               , "QBasicTimer"+                               , "QBitArray"+                               , "QBitmap"+                               , "QBool"+                               , "QBoxLayout"+                               , "QBrush"+                               , "QBuffer"+                               , "QButtonGroup"+                               , "QByteArray"+                               , "QByteArrayMatcher"+                               , "QCDEStyle"+                               , "QCache"+                               , "QCalendarWidget"+                               , "QChar"+                               , "QCheckBox"+                               , "QChildEvent"+                               , "QCleanlooksStyle"+                               , "QClipboard"+                               , "QCloseEvent"+                               , "QColor"+                               , "QColorDialog"+                               , "QColormap"+                               , "QColumnView"+                               , "QComboBox"+                               , "QCommandLinkButton"+                               , "QCommonStyle"+                               , "QCompleter"+                               , "QConicalGradient"+                               , "QContextMenuEvent"+                               , "QContiguousCache"+                               , "QCopChannel"+                               , "QCoreApplication"+                               , "QCryptographicHash"+                               , "QCursor"+                               , "QCustomRasterPaintDevice"+                               , "QDBusAbstractAdaptor"+                               , "QDBusAbstractInterface"+                               , "QDBusArgument"+                               , "QDBusConnection"+                               , "QDBusConnectionInterface"+                               , "QDBusContext"+                               , "QDBusError"+                               , "QDBusInterface"+                               , "QDBusMessage"+                               , "QDBusObjectPath"+                               , "QDBusPendingCall"+                               , "QDBusPendingCallWatcher"+                               , "QDBusPendingReply"+                               , "QDBusReply"+                               , "QDBusServiceWatcher"+                               , "QDBusSignature"+                               , "QDBusUnixFileDescriptor"+                               , "QDBusVariant"+                               , "QDataStream"+                               , "QDataWidgetMapper"+                               , "QDate"+                               , "QDateEdit"+                               , "QDateTime"+                               , "QDateTimeEdit"+                               , "QDebug"+                               , "QDeclarativeComponent"+                               , "QDeclarativeContext"+                               , "QDeclarativeEngine"+                               , "QDeclarativeError"+                               , "QDeclarativeExpression"+                               , "QDeclarativeExtensionPlugin"+                               , "QDeclarativeImageProvider"+                               , "QDeclarativeItem"+                               , "QDeclarativeListProperty"+                               , "QDeclarativeListReference"+                               , "QDeclarativeNetworkAccessManagerFactory"+                               , "QDeclarativeParserStatus"+                               , "QDeclarativeProperty"+                               , "QDeclarativePropertyMap"+                               , "QDeclarativePropertyValueSource"+                               , "QDeclarativeScriptString"+                               , "QDeclarativeView"+                               , "QDecoration"+                               , "QDecorationDefault"+                               , "QDecorationFactory"+                               , "QDecorationPlugin"+                               , "QDesignerActionEditorInterface"+                               , "QDesignerContainerExtension"+                               , "QDesignerCustomWidgetCollectionInterface"+                               , "QDesignerCustomWidgetInterface"+                               , "QDesignerDynamicPropertySheetExtension"+                               , "QDesignerFormEditorInterface"+                               , "QDesignerFormWindowCursorInterface"+                               , "QDesignerFormWindowInterface"+                               , "QDesignerFormWindowManagerInterface"+                               , "QDesignerMemberSheetExtension"+                               , "QDesignerObjectInspectorInterface"+                               , "QDesignerPropertyEditorInterface"+                               , "QDesignerPropertySheetExtension"+                               , "QDesignerTaskMenuExtension"+                               , "QDesignerWidgetBoxInterface"+                               , "QDesktopServices"+                               , "QDesktopWidget"+                               , "QDial"+                               , "QDialog"+                               , "QDialogButtonBox"+                               , "QDir"+                               , "QDirIterator"+                               , "QDirectPainter"+                               , "QDockWidget"+                               , "QDomAttr"+                               , "QDomCDATASection"+                               , "QDomCharacterData"+                               , "QDomComment"+                               , "QDomDocument"+                               , "QDomDocumentFragment"+                               , "QDomDocumentType"+                               , "QDomElement"+                               , "QDomEntity"+                               , "QDomEntityReference"+                               , "QDomImplementation"+                               , "QDomNamedNodeMap"+                               , "QDomNode"+                               , "QDomNodeList"+                               , "QDomNotation"+                               , "QDomProcessingInstruction"+                               , "QDomText"+                               , "QDoubleSpinBox"+                               , "QDoubleValidator"+                               , "QDrag"+                               , "QDragEnterEvent"+                               , "QDragLeaveEvent"+                               , "QDragMoveEvent"+                               , "QDropEvent"+                               , "QDynamicPropertyChangeEvent"+                               , "QEasingCurve"+                               , "QElapsedTimer"+                               , "QErrorMessage"+                               , "QEvent"+                               , "QEventLoop"+                               , "QEventTransition"+                               , "QExplicitlySharedDataPointer"+                               , "QExtensionFactory"+                               , "QExtensionManager"+                               , "QFSFileEngine"+                               , "QFile"+                               , "QFileDialog"+                               , "QFileIconProvider"+                               , "QFileInfo"+                               , "QFileInfoList"+                               , "QFileOpenEvent"+                               , "QFileSystemModel"+                               , "QFileSystemWatcher"+                               , "QFinalState"+                               , "QFlag"+                               , "QFlags"+                               , "QFocusEvent"+                               , "QFocusFrame"+                               , "QFont"+                               , "QFontComboBox"+                               , "QFontDatabase"+                               , "QFontDialog"+                               , "QFontEngineInfo"+                               , "QFontEnginePlugin"+                               , "QFontInfo"+                               , "QFontMetrics"+                               , "QFontMetricsF"+                               , "QFormBuilder"+                               , "QFormLayout"+                               , "QFrame"+                               , "QFtp"+                               , "QFuture"+                               , "QFutureIterator"+                               , "QFutureSynchronizer"+                               , "QFutureWatcher"+                               , "QGLBuffer"+                               , "QGLColormap"+                               , "QGLContext"+                               , "QGLFormat"+                               , "QGLFramebufferObject"+                               , "QGLFramebufferObjectFormat"+                               , "QGLFunctions"+                               , "QGLPixelBuffer"+                               , "QGLShader"+                               , "QGLShaderProgram"+                               , "QGLWidget"+                               , "QGenericArgument"+                               , "QGenericMatrix"+                               , "QGenericPlugin"+                               , "QGenericPluginFactory"+                               , "QGenericReturnArgument"+                               , "QGesture"+                               , "QGestureEvent"+                               , "QGestureRecognizer"+                               , "QGlyphRun"+                               , "QGradient"+                               , "QGraphicsAnchor"+                               , "QGraphicsAnchorLayout"+                               , "QGraphicsBlurEffect"+                               , "QGraphicsColorizeEffect"+                               , "QGraphicsDropShadowEffect"+                               , "QGraphicsEffect"+                               , "QGraphicsEllipseItem"+                               , "QGraphicsGridLayout"+                               , "QGraphicsItem"+                               , "QGraphicsItemAnimation"+                               , "QGraphicsItemGroup"+                               , "QGraphicsLayout"+                               , "QGraphicsLayoutItem"+                               , "QGraphicsLineItem"+                               , "QGraphicsLinearLayout"+                               , "QGraphicsObject"+                               , "QGraphicsOpacityEffect"+                               , "QGraphicsPathItem"+                               , "QGraphicsPixmapItem"+                               , "QGraphicsPolygonItem"+                               , "QGraphicsProxyWidget"+                               , "QGraphicsRectItem"+                               , "QGraphicsRotation"+                               , "QGraphicsScale"+                               , "QGraphicsScene"+                               , "QGraphicsSceneContextMenuEvent"+                               , "QGraphicsSceneDragDropEvent"+                               , "QGraphicsSceneEvent"+                               , "QGraphicsSceneHelpEvent"+                               , "QGraphicsSceneHoverEvent"+                               , "QGraphicsSceneMouseEvent"+                               , "QGraphicsSceneMoveEvent"+                               , "QGraphicsSceneResizeEvent"+                               , "QGraphicsSceneWheelEvent"+                               , "QGraphicsSimpleTextItem"+                               , "QGraphicsSvgItem"+                               , "QGraphicsTextItem"+                               , "QGraphicsTransform"+                               , "QGraphicsView"+                               , "QGraphicsWebView"+                               , "QGraphicsWidget"+                               , "QGridLayout"+                               , "QGroupBox"+                               , "QGtkStyle"+                               , "QHBoxLayout"+                               , "QHash"+                               , "QHashIterator"+                               , "QHeaderView"+                               , "QHelpContentItem"+                               , "QHelpContentModel"+                               , "QHelpContentWidget"+                               , "QHelpEngine"+                               , "QHelpEngineCore"+                               , "QHelpEvent"+                               , "QHelpIndexModel"+                               , "QHelpIndexWidget"+                               , "QHelpSearchEngine"+                               , "QHelpSearchQuery"+                               , "QHelpSearchQueryWidget"+                               , "QHelpSearchResultWidget"+                               , "QHideEvent"+                               , "QHistoryState"+                               , "QHostAddress"+                               , "QHostInfo"+                               , "QHoverEvent"+                               , "QHttpMultiPart"+                               , "QHttpPart"+                               , "QIODevice"+                               , "QIcon"+                               , "QIconDragEvent"+                               , "QIconEngine"+                               , "QIconEnginePlugin"+                               , "QIconEnginePluginV2"+                               , "QIconEngineV2"+                               , "QIdentityProxyModel"+                               , "QImage"+                               , "QImageIOHandler"+                               , "QImageIOPlugin"+                               , "QImageReader"+                               , "QImageWriter"+                               , "QInputContext"+                               , "QInputContextFactory"+                               , "QInputContextPlugin"+                               , "QInputDialog"+                               , "QInputEvent"+                               , "QInputMethodEvent"+                               , "QIntValidator"+                               , "QItemDelegate"+                               , "QItemEditorCreator"+                               , "QItemEditorCreatorBase"+                               , "QItemEditorFactory"+                               , "QItemSelection"+                               , "QItemSelectionModel"+                               , "QItemSelectionRange"+                               , "QKbdDriverFactory"+                               , "QKbdDriverPlugin"+                               , "QKeyEvent"+                               , "QKeyEventTransition"+                               , "QKeySequence"+                               , "QLCDNumber"+                               , "QLabel"+                               , "QLatin1Char"+                               , "QLatin1String"+                               , "QLayout"+                               , "QLayoutItem"+                               , "QLibrary"+                               , "QLibraryInfo"+                               , "QLine"+                               , "QLineEdit"+                               , "QLineF"+                               , "QLinearGradient"+                               , "QLinkedList"+                               , "QLinkedListIterator"+                               , "QList"+                               , "QListIterator"+                               , "QListView"+                               , "QListWidget"+                               , "QListWidgetItem"+                               , "QLocalServer"+                               , "QLocalSocket"+                               , "QLocale"+                               , "QMacCocoaViewContainer"+                               , "QMacNativeWidget"+                               , "QMacPasteboardMime"+                               , "QMacStyle"+                               , "QMainWindow"+                               , "QMap"+                               , "QMapIterator"+                               , "QMargins"+                               , "QMatrix4x4"+                               , "QMdiArea"+                               , "QMdiSubWindow"+                               , "QMenu"+                               , "QMenuBar"+                               , "QMessageBox"+                               , "QMetaClassInfo"+                               , "QMetaEnum"+                               , "QMetaMethod"+                               , "QMetaObject"+                               , "QMetaProperty"+                               , "QMetaType"+                               , "QMimeData"+                               , "QModelIndex"+                               , "QMotifStyle"+                               , "QMouseDriverFactory"+                               , "QMouseDriverPlugin"+                               , "QMouseEvent"+                               , "QMouseEventTransition"+                               , "QMoveEvent"+                               , "QMovie"+                               , "QMultiHash"+                               , "QMultiMap"+                               , "QMutableHashIterator"+                               , "QMutableLinkedListIterator"+                               , "QMutableListIterator"+                               , "QMutableMapIterator"+                               , "QMutableSetIterator"+                               , "QMutableStringListIterator"+                               , "QMutableVectorIterator"+                               , "QMutex"+                               , "QMutexLocker"+                               , "QNetworkAccessManager"+                               , "QNetworkAddressEntry"+                               , "QNetworkCacheMetaData"+                               , "QNetworkConfiguration"+                               , "QNetworkConfigurationManager"+                               , "QNetworkCookie"+                               , "QNetworkCookieJar"+                               , "QNetworkDiskCache"+                               , "QNetworkInterface"+                               , "QNetworkProxy"+                               , "QNetworkProxyFactory"+                               , "QNetworkProxyQuery"+                               , "QNetworkReply"+                               , "QNetworkRequest"+                               , "QNetworkSession"+                               , "QObject"+                               , "QObjectCleanupHandler"+                               , "QPageSetupDialog"+                               , "QPaintDevice"+                               , "QPaintEngine"+                               , "QPaintEngineState"+                               , "QPaintEvent"+                               , "QPainter"+                               , "QPainterPath"+                               , "QPainterPathStroker"+                               , "QPair"+                               , "QPalette"+                               , "QPanGesture"+                               , "QParallelAnimationGroup"+                               , "QPauseAnimation"+                               , "QPen"+                               , "QPersistentModelIndex"+                               , "QPicture"+                               , "QPinchGesture"+                               , "QPixmap"+                               , "QPixmapCache"+                               , "QPlainTextDocumentLayout"+                               , "QPlainTextEdit"+                               , "QPlastiqueStyle"+                               , "QPlatformCursor"+                               , "QPlatformCursorImage"+                               , "QPlatformFontDatabase"+                               , "QPlatformWindowFormat"+                               , "QPluginLoader"+                               , "QPoint"+                               , "QPointF"+                               , "QPointer"+                               , "QPolygon"+                               , "QPolygonF"+                               , "QPrintDialog"+                               , "QPrintEngine"+                               , "QPrintPreviewDialog"+                               , "QPrintPreviewWidget"+                               , "QPrinter"+                               , "QPrinterInfo"+                               , "QProcess"+                               , "QProcessEnvironment"+                               , "QProgressBar"+                               , "QProgressDialog"+                               , "QPropertyAnimation"+                               , "QProxyScreen"+                               , "QProxyScreenCursor"+                               , "QProxyStyle"+                               , "QPushButton"+                               , "QQuaternion"+                               , "QQueue"+                               , "QRadialGradient"+                               , "QRadioButton"+                               , "QRasterPaintEngine"+                               , "QRawFont"+                               , "QReadLocker"+                               , "QReadWriteLock"+                               , "QRect"+                               , "QRectF"+                               , "QRegExp"+                               , "QRegExpValidator"+                               , "QRegion"+                               , "QResizeEvent"+                               , "QResource"+                               , "QRubberBand"+                               , "QRunnable"+                               , "QS60MainAppUi"+                               , "QS60MainApplication"+                               , "QS60MainDocument"+                               , "QS60Style"+                               , "QScopedArrayPointer"+                               , "QScopedPointer"+                               , "QScopedValueRollback"+                               , "QScreen"+                               , "QScreenCursor"+                               , "QScreenDriverFactory"+                               , "QScreenDriverPlugin"+                               , "QScriptClass"+                               , "QScriptClassPropertyIterator"+                               , "QScriptContext"+                               , "QScriptContextInfo"+                               , "QScriptEngine"+                               , "QScriptEngineAgent"+                               , "QScriptEngineDebugger"+                               , "QScriptExtensionPlugin"+                               , "QScriptProgram"+                               , "QScriptString"+                               , "QScriptSyntaxCheckResult"+                               , "QScriptValue"+                               , "QScriptValueIterator"+                               , "QScriptable"+                               , "QScrollArea"+                               , "QScrollBar"+                               , "QSemaphore"+                               , "QSequentialAnimationGroup"+                               , "QSessionManager"+                               , "QSet"+                               , "QSetIterator"+                               , "QSettings"+                               , "QSharedData"+                               , "QSharedDataPointer"+                               , "QSharedMemory"+                               , "QSharedPointer"+                               , "QShortcut"+                               , "QShortcutEvent"+                               , "QShowEvent"+                               , "QSignalMapper"+                               , "QSignalSpy"+                               , "QSignalTransition"+                               , "QSimpleXmlNodeModel"+                               , "QSize"+                               , "QSizeF"+                               , "QSizeGrip"+                               , "QSizePolicy"+                               , "QSlider"+                               , "QSocketNotifier"+                               , "QSortFilterProxyModel"+                               , "QSound"+                               , "QSourceLocation"+                               , "QSpacerItem"+                               , "QSpinBox"+                               , "QSplashScreen"+                               , "QSplitter"+                               , "QSplitterHandle"+                               , "QSqlDatabase"+                               , "QSqlDriver"+                               , "QSqlDriverCreator"+                               , "QSqlDriverCreatorBase"+                               , "QSqlDriverPlugin"+                               , "QSqlError"+                               , "QSqlField"+                               , "QSqlIndex"+                               , "QSqlQuery"+                               , "QSqlQueryModel"+                               , "QSqlRecord"+                               , "QSqlRelation"+                               , "QSqlRelationalDelegate"+                               , "QSqlRelationalTableModel"+                               , "QSqlResult"+                               , "QSqlTableModel"+                               , "QSslCertificate"+                               , "QSslCipher"+                               , "QSslConfiguration"+                               , "QSslError"+                               , "QSslKey"+                               , "QSslSocket"+                               , "QStack"+                               , "QStackedLayout"+                               , "QStackedWidget"+                               , "QStandardItem"+                               , "QStandardItemEditorCreator"+                               , "QStandardItemModel"+                               , "QState"+                               , "QStateMachine"+                               , "QStaticText"+                               , "QStatusBar"+                               , "QStatusTipEvent"+                               , "QString"+                               , "QStringBuilder"+                               , "QStringList"+                               , "QStringListIterator"+                               , "QStringListModel"+                               , "QStringMatcher"+                               , "QStringRef"+                               , "QStyle"+                               , "QStyleFactory"+                               , "QStyleHintReturn"+                               , "QStyleHintReturnMask"+                               , "QStyleHintReturnVariant"+                               , "QStyleOption"+                               , "QStyleOptionButton"+                               , "QStyleOptionComboBox"+                               , "QStyleOptionComplex"+                               , "QStyleOptionDockWidget"+                               , "QStyleOptionFocusRect"+                               , "QStyleOptionFrame"+                               , "QStyleOptionFrameV2"+                               , "QStyleOptionFrameV3"+                               , "QStyleOptionGraphicsItem"+                               , "QStyleOptionGroupBox"+                               , "QStyleOptionHeader"+                               , "QStyleOptionMenuItem"+                               , "QStyleOptionProgressBar"+                               , "QStyleOptionProgressBarV2"+                               , "QStyleOptionQ3DockWindow"+                               , "QStyleOptionQ3ListView"+                               , "QStyleOptionQ3ListViewItem"+                               , "QStyleOptionRubberBand"+                               , "QStyleOptionSizeGrip"+                               , "QStyleOptionSlider"+                               , "QStyleOptionSpinBox"+                               , "QStyleOptionTab"+                               , "QStyleOptionTabBarBase"+                               , "QStyleOptionTabBarBaseV2"+                               , "QStyleOptionTabV2"+                               , "QStyleOptionTabV3"+                               , "QStyleOptionTabWidgetFrame"+                               , "QStyleOptionTabWidgetFrameV2"+                               , "QStyleOptionTitleBar"+                               , "QStyleOptionToolBar"+                               , "QStyleOptionToolBox"+                               , "QStyleOptionToolBoxV2"+                               , "QStyleOptionToolButton"+                               , "QStyleOptionViewItem"+                               , "QStyleOptionViewItemV2"+                               , "QStyleOptionViewItemV3"+                               , "QStyleOptionViewItemV4"+                               , "QStylePainter"+                               , "QStylePlugin"+                               , "QStyledItemDelegate"+                               , "QSupportedWritingSystems"+                               , "QSvgGenerator"+                               , "QSvgRenderer"+                               , "QSvgWidget"+                               , "QSwipeGesture"+                               , "QSymbianEvent"+                               , "QSymbianGraphicsSystemHelper"+                               , "QSyntaxHighlighter"+                               , "QSysInfo"+                               , "QSystemLocale"+                               , "QSystemSemaphore"+                               , "QSystemTrayIcon"+                               , "QTabBar"+                               , "QTabWidget"+                               , "QTableView"+                               , "QTableWidget"+                               , "QTableWidgetItem"+                               , "QTableWidgetSelectionRange"+                               , "QTabletEvent"+                               , "QTapAndHoldGesture"+                               , "QTapGesture"+                               , "QTcpServer"+                               , "QTcpSocket"+                               , "QTemporaryFile"+                               , "QTest"+                               , "QTestEventList"+                               , "QTextBlock"+                               , "QTextBlockFormat"+                               , "QTextBlockGroup"+                               , "QTextBlockUserData"+                               , "QTextBoundaryFinder"+                               , "QTextBrowser"+                               , "QTextCharFormat"+                               , "QTextCodec"+                               , "QTextCodecPlugin"+                               , "QTextCursor"+                               , "QTextDecoder"+                               , "QTextDocument"+                               , "QTextDocumentFragment"+                               , "QTextDocumentWriter"+                               , "QTextEdit"+                               , "QTextEncoder"+                               , "QTextFormat"+                               , "QTextFragment"+                               , "QTextFrame"+                               , "QTextFrameFormat"+                               , "QTextImageFormat"+                               , "QTextInlineObject"+                               , "QTextItem"+                               , "QTextLayout"+                               , "QTextLength"+                               , "QTextLine"+                               , "QTextList"+                               , "QTextListFormat"+                               , "QTextObject"+                               , "QTextObjectInterface"+                               , "QTextOption"+                               , "QTextStream"+                               , "QTextTable"+                               , "QTextTableCell"+                               , "QTextTableCellFormat"+                               , "QTextTableFormat"+                               , "QThread"+                               , "QThreadPool"+                               , "QThreadStorage"+                               , "QTileRules"+                               , "QTime"+                               , "QTimeEdit"+                               , "QTimeLine"+                               , "QTimer"+                               , "QTimerEvent"+                               , "QToolBar"+                               , "QToolBox"+                               , "QToolButton"+                               , "QToolTip"+                               , "QTouchEvent"+                               , "QTouchEventSequence"+                               , "QTransform"+                               , "QTranslator"+                               , "QTreeView"+                               , "QTreeWidget"+                               , "QTreeWidgetItem"+                               , "QTreeWidgetItemIterator"+                               , "QUdpSocket"+                               , "QUiLoader"+                               , "QUndoCommand"+                               , "QUndoGroup"+                               , "QUndoStack"+                               , "QUndoView"+                               , "QUrl"+                               , "QUrlInfo"+                               , "QUuid"+                               , "QVBoxLayout"+                               , "QValidator"+                               , "QVarLengthArray"+                               , "QVariant"+                               , "QVariantAnimation"+                               , "QVector"+                               , "QVector2D"+                               , "QVector3D"+                               , "QVector4D"+                               , "QVectorIterator"+                               , "QVideoFrame"+                               , "QVideoSurfaceFormat"+                               , "QWSCalibratedMouseHandler"+                               , "QWSClient"+                               , "QWSEmbedWidget"+                               , "QWSEvent"+                               , "QWSGLWindowSurface"+                               , "QWSInputMethod"+                               , "QWSKeyboardHandler"+                               , "QWSMouseHandler"+                               , "QWSPointerCalibrationData"+                               , "QWSScreenSaver"+                               , "QWSServer"+                               , "QWSWindow"+                               , "QWaitCondition"+                               , "QWeakPointer"+                               , "QWebDatabase"+                               , "QWebElement"+                               , "QWebElementCollection"+                               , "QWebFrame"+                               , "QWebHistory"+                               , "QWebHistoryInterface"+                               , "QWebHistoryItem"+                               , "QWebHitTestResult"+                               , "QWebInspector"+                               , "QWebPage"+                               , "QWebPluginFactory"+                               , "QWebSecurityOrigin"+                               , "QWebSettings"+                               , "QWebView"+                               , "QWhatsThis"+                               , "QWhatsThisClickedEvent"+                               , "QWheelEvent"+                               , "QWidget"+                               , "QWidgetAction"+                               , "QWidgetItem"+                               , "QWidgetList"+                               , "QWindowStateChangeEvent"+                               , "QWindowsMime"+                               , "QWindowsStyle"+                               , "QWindowsVistaStyle"+                               , "QWindowsXPStyle"+                               , "QWizard"+                               , "QWizardPage"+                               , "QWriteLocker"+                               , "QX11EmbedContainer"+                               , "QX11EmbedWidget"+                               , "QX11Info"+                               , "QXmlAttributes"+                               , "QXmlContentHandler"+                               , "QXmlDTDHandler"+                               , "QXmlDeclHandler"+                               , "QXmlDefaultHandler"+                               , "QXmlEntityResolver"+                               , "QXmlErrorHandler"+                               , "QXmlFormatter"+                               , "QXmlInputSource"+                               , "QXmlItem"+                               , "QXmlLexicalHandler"+                               , "QXmlLocator"+                               , "QXmlName"+                               , "QXmlNamePool"+                               , "QXmlNamespaceSupport"+                               , "QXmlNodeModelIndex"+                               , "QXmlParseException"+                               , "QXmlQuery"+                               , "QXmlReader"+                               , "QXmlResultItems"+                               , "QXmlSchema"+                               , "QXmlSchemaValidator"+                               , "QXmlSerializer"+                               , "QXmlSimpleReader"+                               , "QXmlStreamAttribute"+                               , "QXmlStreamAttributes"+                               , "QXmlStreamEntityDeclaration"+                               , "QXmlStreamEntityResolver"+                               , "QXmlStreamNamespaceDeclaration"+                               , "QXmlStreamNotationDeclaration"+                               , "QXmlStreamReader"+                               , "QXmlStreamWriter"+                               , "Qt"+                               , "QtConcurrent"+                               ])+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C++" , "QtClassMember" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "connect"+                               , "disconnect"+                               , "qAbs"+                               , "qAddPostRoutine"+                               , "qAlpha"+                               , "qBinaryFind"+                               , "qBlue"+                               , "qBound"+                               , "qChecksum"+                               , "qCompress"+                               , "qCopy"+                               , "qCopyBackward"+                               , "qCount"+                               , "qCritical"+                               , "qDBusRegisterMetaType"+                               , "qDebug"+                               , "qDeleteAll"+                               , "qEqual"+                               , "qFatal"+                               , "qFill"+                               , "qFind"+                               , "qFindChildren"+                               , "qFuzzyCompare"+                               , "qGray"+                               , "qGreater"+                               , "qGreen"+                               , "qHash"+                               , "qInstallMsgHandler"+                               , "qLess"+                               , "qLowerBound"+                               , "qMacVersion"+                               , "qMakePair"+                               , "qMax"+                               , "qMetaTypeId"+                               , "qMin"+                               , "qPrintable"+                               , "qRed"+                               , "qRegisterMetaType"+                               , "qRegisterMetaTypeStreamOperators"+                               , "qRgb"+                               , "qRgba"+                               , "qRound"+                               , "qRound64"+                               , "qSort"+                               , "qStableSort"+                               , "qSwap"+                               , "qUncompress"+                               , "qUpperBound"+                               , "qVersion"+                               , "qWarning"+                               , "qWebKitMajorVersion"+                               , "qWebKitMinorVersion"+                               , "qWebKitVersion"+                               , "q_check_ptr"+                               , "qdbus_cast"+                               , "qgetenv"+                               , "qmlInfo"+                               , "qmlRegisterInterface"+                               , "qmlRegisterType"+                               , "qmlRegisterTypeNotAvailable"+                               , "qmlRegisterUncreatableType"+                               , "qobject_cast"+                               , "qrand"+                               , "qsnprintf"+                               , "qsrand"+                               , "qstrcmp"+                               , "qstrcpy"+                               , "qstrdup"+                               , "qstricmp"+                               , "qstrlen"+                               , "qstrncmp"+                               , "qstrncpy"+                               , "qstrnicmp"+                               , "qstrnlen"+                               , "qtTrId"+                               , "qt_extension"+                               , "qt_set_sequence_auto_mnemonic"+                               , "qt_symbian_exception2Error"+                               , "qt_symbian_exception2LeaveL"+                               , "qt_symbian_throwIfError"+                               , "qvsnprintf"+                               , "staticMetaObject"+                               , "tr"+                               , "trUtf8"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "QAXCLASS"+                               , "QAXFACTORY_BEGIN"+                               , "QAXFACTORY_DEFAULT"+                               , "QAXFACTORY_END"+                               , "QAXFACTORY_EXPORT"+                               , "QAXTYPE"+                               , "QBENCHMARK"+                               , "QBENCHMARK_ONCE"+                               , "QCOMPARE"+                               , "QDESIGNER_WIDGET_EXPORT"+                               , "QEXPECT_FAIL"+                               , "QFAIL"+                               , "QFETCH"+                               , "QML_DECLARE_TYPE"+                               , "QML_DECLARE_TYPEINFO"+                               , "QSKIP"+                               , "QT3_SUPPORT"+                               , "QT3_SUPPORT_CONSTRUCTOR"+                               , "QT3_SUPPORT_VARIABLE"+                               , "QT3_SUPPORT_WARNINGS"+                               , "QTEST"+                               , "QTEST_APPLESS_MAIN"+                               , "QTEST_MAIN"+                               , "QTEST_NOOP_MAIN"+                               , "QTWEBKIT_VERSION"+                               , "QTWEBKIT_VERSION_CHECK"+                               , "QTWEBKIT_VERSION_STR"+                               , "QT_ARCH_X86_64"+                               , "QT_ASCII_CAST_WARN"+                               , "QT_ASCII_CAST_WARN_CONSTRUCTOR"+                               , "QT_BEGIN_HEADER"+                               , "QT_BEGIN_NAMESPACE"+                               , "QT_BUILD_KEY"+                               , "QT_BUILD_KEY_COMPAT"+                               , "QT_CATCH"+                               , "QT_COMPAT"+                               , "QT_COMPAT_WARNINGS"+                               , "QT_DEBUG"+                               , "QT_DEPRECATED"+                               , "QT_DEPRECATED_CONSTRUCTOR"+                               , "QT_DEPRECATED_VARIABLE"+                               , "QT_EDITION"+                               , "QT_EDITION_ACADEMIC"+                               , "QT_EDITION_CONSOLE"+                               , "QT_EDITION_DESKTOP"+                               , "QT_EDITION_DESKTOPLIGHT"+                               , "QT_EDITION_EDUCATIONAL"+                               , "QT_EDITION_EVALUATION"+                               , "QT_EDITION_OPENSOURCE"+                               , "QT_EDITION_UNIVERSAL"+                               , "QT_END_HEADER"+                               , "QT_END_NAMESPACE"+                               , "QT_ENSURE_STACK_ALIGNED_FOR_SSE"+                               , "QT_FASTCALL"+                               , "QT_FORWARD_DECLARE_CLASS"+                               , "QT_FORWARD_DECLARE_STRUCT"+                               , "QT_HAVE_ARMV6"+                               , "QT_LARGEFILE_SUPPORT"+                               , "QT_LICENSED_MODULE"+                               , "QT_LINKED_OPENSSL"+                               , "QT_LINUXBASE"+                               , "QT_MAC_USE_COCOA"+                               , "QT_MOC_COMPAT"+                               , "QT_MODULE"+                               , "QT_MODULE_ACTIVEQT"+                               , "QT_MODULE_CORE"+                               , "QT_MODULE_DBUS"+                               , "QT_MODULE_DECLARATIVE"+                               , "QT_MODULE_GRAPHICSVIEW"+                               , "QT_MODULE_GUI"+                               , "QT_MODULE_HELP"+                               , "QT_MODULE_MULTIMEDIA"+                               , "QT_MODULE_NETWORK"+                               , "QT_MODULE_OPENGL"+                               , "QT_MODULE_OPENVG"+                               , "QT_MODULE_QT3SUPPORT"+                               , "QT_MODULE_QT3SUPPORTLIGHT"+                               , "QT_MODULE_SCRIPT"+                               , "QT_MODULE_SCRIPTTOOLS"+                               , "QT_MODULE_SQL"+                               , "QT_MODULE_SVG"+                               , "QT_MODULE_TEST"+                               , "QT_MODULE_XML"+                               , "QT_MODULE_XMLPATTERNS"+                               , "QT_NO_ACCESSIBILITY"+                               , "QT_NO_ANIMATION"+                               , "QT_NO_ARM_EABI"+                               , "QT_NO_BEARERMANAGEMENT"+                               , "QT_NO_BUTTONGROUP"+                               , "QT_NO_CALENDARWIDGET"+                               , "QT_NO_CAST_FROM_ASCII"+                               , "QT_NO_CAST_FROM_BYTEARRAY"+                               , "QT_NO_CAST_TO_ASCII"+                               , "QT_NO_CLIPBOARD"+                               , "QT_NO_CODECS"+                               , "QT_NO_COLORDIALOG"+                               , "QT_NO_COLUMNVIEW"+                               , "QT_NO_COMBOBOX"+                               , "QT_NO_COMPLETER"+                               , "QT_NO_CONCURRENT"+                               , "QT_NO_CONCURRENT_FILTER"+                               , "QT_NO_CONCURRENT_MAP"+                               , "QT_NO_CONTEXTMENU"+                               , "QT_NO_COP"+                               , "QT_NO_CRASHHANDLER"+                               , "QT_NO_CUPS"+                               , "QT_NO_DATAWIDGETMAPPER"+                               , "QT_NO_DATESTRING"+                               , "QT_NO_DATETIMEEDIT"+                               , "QT_NO_DBUS"+                               , "QT_NO_DEBUG"+                               , "QT_NO_DEBUG_STREAM"+                               , "QT_NO_DECLARATIVE"+                               , "QT_NO_DIAL"+                               , "QT_NO_DIRMODEL"+                               , "QT_NO_DOCKWIDGET"+                               , "QT_NO_DRAGANDDROP"+                               , "QT_NO_EGL"+                               , "QT_NO_ERRORMESSAGE"+                               , "QT_NO_EXCEPTIONS"+                               , "QT_NO_FILEDIALOG"+                               , "QT_NO_FILESYSTEMMODEL"+                               , "QT_NO_FONTCOMBOBOX"+                               , "QT_NO_FONTCONFIG"+                               , "QT_NO_FONTDIALOG"+                               , "QT_NO_FPU"+                               , "QT_NO_FSCOMPLETER"+                               , "QT_NO_FTP"+                               , "QT_NO_GETIFADDRS"+                               , "QT_NO_GRAPHICSEFFECT"+                               , "QT_NO_GRAPHICSSVGITEM"+                               , "QT_NO_GRAPHICSVIEW"+                               , "QT_NO_GSTREAMER"+                               , "QT_NO_HOSTINFO"+                               , "QT_NO_HTTP"+                               , "QT_NO_ICD"+                               , "QT_NO_IM"+                               , "QT_NO_IMAGEFORMAT_JPEG"+                               , "QT_NO_IMAGEFORMAT_MNG"+                               , "QT_NO_IMAGEFORMAT_PNG"+                               , "QT_NO_IMAGEFORMAT_TIFF"+                               , "QT_NO_IMAGEFORMAT_XPM"+                               , "QT_NO_INPUTDIALOG"+                               , "QT_NO_ITEMVIEWS"+                               , "QT_NO_LIBRARY"+                               , "QT_NO_LISTVIEW"+                               , "QT_NO_LISTWIDGET"+                               , "QT_NO_LPR"+                               , "QT_NO_MAINWINDOW"+                               , "QT_NO_MDIAREA"+                               , "QT_NO_MENU"+                               , "QT_NO_MENUBAR"+                               , "QT_NO_MITSHM"+                               , "QT_NO_MULTIMEDIA"+                               , "QT_NO_NAS"+                               , "QT_NO_NETWORKDISKCACHE"+                               , "QT_NO_OPENGL"+                               , "QT_NO_OPENVG"+                               , "QT_NO_PAINT_DEBUG"+                               , "QT_NO_PHONON"+                               , "QT_NO_PHONON_EFFECTWIDGET"+                               , "QT_NO_PHONON_PLATFORMPLUGIN"+                               , "QT_NO_PHONON_SEEKSLIDER"+                               , "QT_NO_PHONON_SETTINGSGROUP"+                               , "QT_NO_PHONON_VIDEOPLAYER"+                               , "QT_NO_PHONON_VOLUMEFADEREFFECT"+                               , "QT_NO_PHONON_VOLUMESLIDER"+                               , "QT_NO_PRINTDIALOG"+                               , "QT_NO_PRINTER"+                               , "QT_NO_PRINTPREVIEWDIALOG"+                               , "QT_NO_PRINTPREVIEWWIDGET"+                               , "QT_NO_PROCESS"+                               , "QT_NO_PROGRESSDIALOG"+                               , "QT_NO_PROXYMODEL"+                               , "QT_NO_PULSEAUDIO"+                               , "QT_NO_QDEBUG_MACRO"+                               , "QT_NO_QFUTURE"+                               , "QT_NO_QWARNING_MACRO"+                               , "QT_NO_QWS_CURSOR"+                               , "QT_NO_QWS_DECORATION_STYLED"+                               , "QT_NO_QWS_DECORATION_WINDOWS"+                               , "QT_NO_QWS_DYNAMICSCREENTRANSFORMATION"+                               , "QT_NO_QWS_INPUTMETHODS"+                               , "QT_NO_QWS_MANAGER"+                               , "QT_NO_QWS_MULTIPROCESS"+                               , "QT_NO_QWS_SOUNDSERVER"+                               , "QT_NO_QWS_TRANSFORMED"+                               , "QT_NO_QWS_VNC"+                               , "QT_NO_RAWFONT"+                               , "QT_NO_S60"+                               , "QT_NO_SCRIPT"+                               , "QT_NO_SCRIPTTOOLS"+                               , "QT_NO_SCROLLAREA"+                               , "QT_NO_SCROLLBAR"+                               , "QT_NO_SESSIONMANAGER"+                               , "QT_NO_SHAPE"+                               , "QT_NO_SHAREDMEMORY"+                               , "QT_NO_SOCKS5"+                               , "QT_NO_SOFTKEYMANAGER"+                               , "QT_NO_SORTFILTERPROXYMODEL"+                               , "QT_NO_SPINBOX"+                               , "QT_NO_SPLITTER"+                               , "QT_NO_STANDARDITEMMODEL"+                               , "QT_NO_STATEMACHINE"+                               , "QT_NO_STL_WCHAR"+                               , "QT_NO_STRINGLISTMODEL"+                               , "QT_NO_STYLE_CDE"+                               , "QT_NO_STYLE_CLEANLOOKS"+                               , "QT_NO_STYLE_GTK"+                               , "QT_NO_STYLE_PLASTIQUE"+                               , "QT_NO_STYLE_S60"+                               , "QT_NO_STYLE_STYLESHEET"+                               , "QT_NO_STYLE_WINDOWSCE"+                               , "QT_NO_STYLE_WINDOWSMOBILE"+                               , "QT_NO_STYLE_WINDOWSVISTA"+                               , "QT_NO_STYLE_WINDOWSXP"+                               , "QT_NO_SVG"+                               , "QT_NO_SVGGENERATOR"+                               , "QT_NO_SVGRENDERER"+                               , "QT_NO_SVGWIDGET"+                               , "QT_NO_SXE"+                               , "QT_NO_SYNTAXHIGHLIGHTER"+                               , "QT_NO_SYSTEMSEMAPHORE"+                               , "QT_NO_TABBAR"+                               , "QT_NO_TABDIALOG"+                               , "QT_NO_TABLET"+                               , "QT_NO_TABLEVIEW"+                               , "QT_NO_TABLEWIDGET"+                               , "QT_NO_TABWIDGET"+                               , "QT_NO_TEMPLATE_TEMPLATE_PARAMETERS"+                               , "QT_NO_TEXTBROWSER"+                               , "QT_NO_TEXTCODECPLUGIN"+                               , "QT_NO_TEXTEDIT"+                               , "QT_NO_TEXTODFWRITER"+                               , "QT_NO_TOOLBAR"+                               , "QT_NO_TOOLBOX"+                               , "QT_NO_TOOLBUTTON"+                               , "QT_NO_TRANSLATION_UTF8"+                               , "QT_NO_TREEVIEW"+                               , "QT_NO_TREEWIDGET"+                               , "QT_NO_UNDOGROUP"+                               , "QT_NO_UNDOSTACK"+                               , "QT_NO_UNDOVIEW"+                               , "QT_NO_URL_CAST_FROM_STRING"+                               , "QT_NO_WARNINGS"+                               , "QT_NO_WEBKIT"+                               , "QT_NO_WHATSTHIS"+                               , "QT_NO_WIN_ACTIVEQT"+                               , "QT_NO_WIZARD"+                               , "QT_NO_WORKSPACE"+                               , "QT_NO_XCURSOR"+                               , "QT_NO_XFIXES"+                               , "QT_NO_XINERAMA"+                               , "QT_NO_XINPUT"+                               , "QT_NO_XKB"+                               , "QT_NO_XMLPATTERNS"+                               , "QT_NO_XMLSTREAMREADER"+                               , "QT_NO_XMLSTREAMWRITER"+                               , "QT_NO_XRANDR"+                               , "QT_NO_XRENDER"+                               , "QT_NO_XSYNC"+                               , "QT_NO_XVIDEO"+                               , "QT_NO_ZLIB"+                               , "QT_PACKAGEDATE_STR"+                               , "QT_PACKAGE_TAG"+                               , "QT_POINTER_SIZE"+                               , "QT_PREPEND_NAMESPACE"+                               , "QT_PRODUCT_LICENSE"+                               , "QT_PRODUCT_LICENSEE"+                               , "QT_RETHROW"+                               , "QT_STATIC_CONST"+                               , "QT_STATIC_CONST_IMPL"+                               , "QT_STRINGIFY"+                               , "QT_STRINGIFY2"+                               , "QT_SUPPORTS"+                               , "QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER"+                               , "QT_SYMBIAN_SUPPORTS_SGIMAGE"+                               , "QT_THROW"+                               , "QT_TRANSLATE_NOOP"+                               , "QT_TRANSLATE_NOOP3"+                               , "QT_TRANSLATE_NOOP3_UTF8"+                               , "QT_TRANSLATE_NOOP_UTF8"+                               , "QT_TRAP_THROWING"+                               , "QT_TRID_NOOP"+                               , "QT_TRY"+                               , "QT_TRYCATCH_ERROR"+                               , "QT_TRYCATCH_LEAVING"+                               , "QT_TR_NOOP"+                               , "QT_TR_NOOP_UTF8"+                               , "QT_USE_MATH_H_FLOATS"+                               , "QT_USE_NAMESPACE"+                               , "QT_USE_QSTRINGBUILDER"+                               , "QT_VERSION"+                               , "QT_VERSION_CHECK"+                               , "QT_VERSION_STR"+                               , "QT_VISIBILITY_AVAILABLE"+                               , "QT_WA"+                               , "QT_WA_INLINE"+                               , "QT_WIN_CALLBACK"+                               , "QVERIFY"+                               , "QVERIFY2"+                               , "QWARN"+                               , "QWIDGETSIZE_MAX"+                               , "Q_ALIGNOF"+                               , "Q_ARG"+                               , "Q_ASSERT"+                               , "Q_ASSERT_X"+                               , "Q_ATOMIC_INT_FETCH_AND_ADD_IS_ALWAYS_NATIVE"+                               , "Q_ATOMIC_INT_FETCH_AND_ADD_IS_NOT_NATIVE"+                               , "Q_ATOMIC_INT_FETCH_AND_ADD_IS_SOMETIMES_NATIVE"+                               , "Q_ATOMIC_INT_FETCH_AND_ADD_IS_WAIT_FREE"+                               , "Q_ATOMIC_INT_FETCH_AND_STORE_IS_ALWAYS_NATIVE"+                               , "Q_ATOMIC_INT_FETCH_AND_STORE_IS_NOT_NATIVE"+                               , "Q_ATOMIC_INT_FETCH_AND_STORE_IS_SOMETIMES_NATIVE"+                               , "Q_ATOMIC_INT_FETCH_AND_STORE_IS_WAIT_FREE"+                               , "Q_ATOMIC_INT_REFERENCE_COUNTING_IS_ALWAYS_NATIVE"+                               , "Q_ATOMIC_INT_REFERENCE_COUNTING_IS_NOT_NATIVE"+                               , "Q_ATOMIC_INT_REFERENCE_COUNTING_IS_SOMETIMES_NATIVE"+                               , "Q_ATOMIC_INT_REFERENCE_COUNTING_IS_WAIT_FREE"+                               , "Q_ATOMIC_INT_TEST_AND_SET_IS_ALWAYS_NATIVE"+                               , "Q_ATOMIC_INT_TEST_AND_SET_IS_NOT_NATIVE"+                               , "Q_ATOMIC_INT_TEST_AND_SET_IS_SOMETIMES_NATIVE"+                               , "Q_ATOMIC_INT_TEST_AND_SET_IS_WAIT_FREE"+                               , "Q_BIG_ENDIAN"+                               , "Q_BROKEN_DEBUG_STREAM"+                               , "Q_BROKEN_TEMPLATE_SPECIALIZATION"+                               , "Q_BYTE_ORDER"+                               , "Q_CANNOT_DELETE_CONSTANT"+                               , "Q_CC_BOR"+                               , "Q_CC_CDS"+                               , "Q_CC_CLANG"+                               , "Q_CC_COMEAU"+                               , "Q_CC_DEC"+                               , "Q_CC_DIAB"+                               , "Q_CC_EDG"+                               , "Q_CC_GCCE"+                               , "Q_CC_GHS"+                               , "Q_CC_GNU"+                               , "Q_CC_HIGHC"+                               , "Q_CC_HP"+                               , "Q_CC_HPACC"+                               , "Q_CC_INTEL"+                               , "Q_CC_KAI"+                               , "Q_CC_MINGW"+                               , "Q_CC_MIPS"+                               , "Q_CC_MSVC"+                               , "Q_CC_MSVC_NET"+                               , "Q_CC_MWERKS"+                               , "Q_CC_NOKIAX86"+                               , "Q_CC_OC"+                               , "Q_CC_PGI"+                               , "Q_CC_RVCT"+                               , "Q_CC_SUN"+                               , "Q_CC_SYM"+                               , "Q_CC_USLC"+                               , "Q_CC_WAT"+                               , "Q_CC_XLC"+                               , "Q_CHECK_PTR"+                               , "Q_CLASSINFO"+                               , "Q_CLEANUP_RESOURCE"+                               , "Q_COMPILER_AUTO_TYPE"+                               , "Q_COMPILER_CLASS_ENUM"+                               , "Q_COMPILER_CONSTEXPR"+                               , "Q_COMPILER_DECLTYPE"+                               , "Q_COMPILER_DEFAULT_DELETE_MEMBERS"+                               , "Q_COMPILER_EXTERN_TEMPLATES"+                               , "Q_COMPILER_INITIALIZER_LISTS"+                               , "Q_COMPILER_LAMBDA"+                               , "Q_COMPILER_MANGLES_RETURN_TYPE"+                               , "Q_COMPILER_RVALUE_REFS"+                               , "Q_COMPILER_UNICODE_STRINGS"+                               , "Q_COMPILER_VARIADIC_TEMPLATES"+                               , "Q_COMPLEX_TYPE"+                               , "Q_CONSTRUCTOR_FUNCTION"+                               , "Q_CONSTRUCTOR_FUNCTION0"+                               , "Q_C_CALLBACKS"+                               , "Q_D"+                               , "Q_DECLARE_EXTENSION_INTERFACE"+                               , "Q_DECLARE_FLAGS"+                               , "Q_DECLARE_INCOMPATIBLE_FLAGS"+                               , "Q_DECLARE_INTERFACE"+                               , "Q_DECLARE_METATYPE"+                               , "Q_DECLARE_OPERATORS_FOR_FLAGS"+                               , "Q_DECLARE_PRIVATE"+                               , "Q_DECLARE_PRIVATE_D"+                               , "Q_DECLARE_PUBLIC"+                               , "Q_DECLARE_SHARED"+                               , "Q_DECLARE_SHARED_STL"+                               , "Q_DECLARE_TR_FUNCTIONS"+                               , "Q_DECLARE_TYPEINFO"+                               , "Q_DECLARE_TYPEINFO_BODY"+                               , "Q_DECL_ALIGN"+                               , "Q_DECL_CONSTEXPR"+                               , "Q_DECL_CONSTRUCTOR_DEPRECATED"+                               , "Q_DECL_DEPRECATED"+                               , "Q_DECL_FINAL"+                               , "Q_DECL_HIDDEN"+                               , "Q_DECL_IMPORT"+                               , "Q_DECL_NOEXCEPT"+                               , "Q_DECL_NOTHROW"+                               , "Q_DECL_OVERRIDE"+                               , "Q_DECL_VARIABLE_DEPRECATED"+                               , "Q_DESTRUCTOR_FUNCTION"+                               , "Q_DESTRUCTOR_FUNCTION0"+                               , "Q_DISABLE_COPY"+                               , "Q_DUMMY_COMPARISON_OPERATOR"+                               , "Q_DUMMY_TYPE"+                               , "Q_EMIT"+                               , "Q_ENUMS"+                               , "Q_EXPORT_PLUGIN2"+                               , "Q_FLAGS"+                               , "Q_FOREACH"+                               , "Q_FOREVER"+                               , "Q_FULL_TEMPLATE_INSTANTIATION"+                               , "Q_FUNC_INFO"+                               , "Q_GLOBAL_STATIC"+                               , "Q_GLOBAL_STATIC_INIT"+                               , "Q_GLOBAL_STATIC_WITH_ARGS"+                               , "Q_GLOBAL_STATIC_WITH_INITIALIZER"+                               , "Q_IMPORT_PLUGIN"+                               , "Q_INIT_RESOURCE"+                               , "Q_INIT_RESOURCE_EXTERN"+                               , "Q_INLINE_TEMPLATE"+                               , "Q_INT64_C"+                               , "Q_INTERFACES"+                               , "Q_INVOKABLE"+                               , "Q_LIKELY"+                               , "Q_LITTLE_ENDIAN"+                               , "Q_MOVABLE_TYPE"+                               , "Q_NOREPLY"+                               , "Q_NO_BOOL_TYPE"+                               , "Q_NO_DATA_RELOCATION"+                               , "Q_NO_DECLARED_NOT_DEFINED"+                               , "Q_NO_DEPRECATED_CONSTRUCTORS"+                               , "Q_NO_EXPLICIT_KEYWORD"+                               , "Q_NO_PACKED_REFERENCE"+                               , "Q_NO_POSIX_SIGNALS"+                               , "Q_NO_TEMPLATE_FRIENDS"+                               , "Q_NO_USING_KEYWORD"+                               , "Q_NULLPTR"+                               , "Q_OBJECT"+                               , "Q_OF_ELF"+                               , "Q_OS_AIX"+                               , "Q_OS_BSD4"+                               , "Q_OS_BSDI"+                               , "Q_OS_CYGWIN"+                               , "Q_OS_DARWIN"+                               , "Q_OS_DARWIN32"+                               , "Q_OS_DARWIN64"+                               , "Q_OS_DGUX"+                               , "Q_OS_DYNIX"+                               , "Q_OS_FREEBSD"+                               , "Q_OS_HPUX"+                               , "Q_OS_HURD"+                               , "Q_OS_INTEGRITY"+                               , "Q_OS_IRIX"+                               , "Q_OS_LINUX"+                               , "Q_OS_LYNX"+                               , "Q_OS_MAC"+                               , "Q_OS_MAC32"+                               , "Q_OS_MAC64"+                               , "Q_OS_MACX"+                               , "Q_OS_MSDOS"+                               , "Q_OS_NACL"+                               , "Q_OS_NETBSD"+                               , "Q_OS_OPENBSD"+                               , "Q_OS_OS2"+                               , "Q_OS_OS2EMX"+                               , "Q_OS_OSF"+                               , "Q_OS_QNX"+                               , "Q_OS_RELIANT"+                               , "Q_OS_SCO"+                               , "Q_OS_SOLARIS"+                               , "Q_OS_SYMBIAN"+                               , "Q_OS_ULTRIX"+                               , "Q_OS_UNIX"+                               , "Q_OS_UNIXWARE"+                               , "Q_OS_VXWORKS"+                               , "Q_OS_WIN"+                               , "Q_OS_WIN32"+                               , "Q_OS_WIN64"+                               , "Q_OS_WINCE"+                               , "Q_OUTOFLINE_TEMPLATE"+                               , "Q_PACKED"+                               , "Q_PRIMITIVE_TYPE"+                               , "Q_PROPERTY"+                               , "Q_Q"+                               , "Q_REQUIRED_RESULT"+                               , "Q_RETURN_ARG"+                               , "Q_SCRIPT_DECLARE_QMETAOBJECT"+                               , "Q_SIGNAL"+                               , "Q_SIGNALS"+                               , "Q_SLOT"+                               , "Q_SLOTS"+                               , "Q_STATIC_TYPE"+                               , "Q_SYMBIAN_FIXED_POINTER_CURSORS"+                               , "Q_SYMBIAN_HAS_EXTENDED_BITMAP_TYPE"+                               , "Q_SYMBIAN_SEMITRANSPARENT_BG_SURFACE"+                               , "Q_SYMBIAN_SUPPORTS_FIXNATIVEORIENTATION"+                               , "Q_SYMBIAN_SUPPORTS_MULTIPLE_SCREENS"+                               , "Q_SYMBIAN_SUPPORTS_SURFACES"+                               , "Q_SYMBIAN_TRANSITION_EFFECTS"+                               , "Q_SYMBIAN_WINDOW_SIZE_CACHE"+                               , "Q_TEMPLATEDLL"+                               , "Q_TYPENAME"+                               , "Q_TYPEOF"+                               , "Q_UINT64_C"+                               , "Q_UNLIKELY"+                               , "Q_UNUSED"+                               , "Q_WRONG_SB_CTYPE_MACROS"+                               , "Q_WS_MAC"+                               , "Q_WS_MAC32"+                               , "Q_WS_MAC64"+                               , "Q_WS_MACX"+                               , "Q_WS_PM"+                               , "Q_WS_S60"+                               , "Q_WS_WIN"+                               , "Q_WS_WIN16"+                               , "Q_WS_WIN32"+                               , "Q_WS_WIN64"+                               , "Q_WS_WINCE"+                               , "Q_WS_WINCE_WM"+                               , "Q_WS_X11"+                               , "SIGNAL"+                               , "SLOT"+                               , "emit"+                               , "foreach"+                               , "forever"+                               , "qApp"+                               , "signals"+                               , "slots"+                               ])+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "C++"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "C++" , "DetectQt4Extensions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "ISO C++" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "QtClassMember"+          , Context+              { cName = "QtClassMember"+              , cSyntax = "C++"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "C++" , "DetectNSEnd" )+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ExtensionTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Alex Turbov (i.zaufi@gmail.com)"+  , sVersion = "3"+  , sLicense = "LGPL"+  , sExtensions =+      [ "*.c++"+      , "*.cxx"+      , "*.cpp"+      , "*.cc"+      , "*.C"+      , "*.h"+      , "*.hh"+      , "*.H"+      , "*.h++"+      , "*.hxx"+      , "*.hpp"+      , "*.hcc"+      , "*.moc"+      ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Cs.hs view
@@ -0,0 +1,713 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Cs (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "C#"+  , sFilename = "cs.xml"+  , sShortname = "Cs"+  , sContexts =+      fromList+        [ ( "Commentar 1"+          , Context+              { cName = "Commentar 1"+              , cSyntax = "C#"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Commentar 2"+          , Context+              { cName = "Commentar 2"+              , cSyntax = "C#"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Member"+          , Context+              { cName = "Member"+              , cSyntax = "C#"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[_\\w][_\\w\\d]*(?=[\\s]*)"+                              , reCompiled =+                                  Just (compileRegex True "\\b[_\\w][_\\w\\d]*(?=[\\s]*)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "C#"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "#define"+                               , "#elif"+                               , "#else"+                               , "#endif"+                               , "#error"+                               , "#if"+                               , "#line"+                               , "#undef"+                               , "#warning"+                               , "abstract"+                               , "as"+                               , "base"+                               , "break"+                               , "case"+                               , "catch"+                               , "checked"+                               , "class"+                               , "continue"+                               , "default"+                               , "delegate"+                               , "do"+                               , "else"+                               , "enum"+                               , "event"+                               , "explicit"+                               , "extern"+                               , "false"+                               , "finally"+                               , "fixed"+                               , "for"+                               , "foreach"+                               , "goto"+                               , "if"+                               , "implicit"+                               , "in"+                               , "interface"+                               , "internal"+                               , "is"+                               , "lock"+                               , "namespace"+                               , "new"+                               , "null"+                               , "operator"+                               , "out"+                               , "override"+                               , "params"+                               , "private"+                               , "protected"+                               , "public"+                               , "readonly"+                               , "ref"+                               , "return"+                               , "sealed"+                               , "sizeof"+                               , "stackalloc"+                               , "static"+                               , "struct"+                               , "switch"+                               , "this"+                               , "throw"+                               , "true"+                               , "try"+                               , "typeof"+                               , "unchecked"+                               , "unsafe"+                               , "using"+                               , "virtual"+                               , "while"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "bool"+                               , "byte"+                               , "char"+                               , "const"+                               , "decimal"+                               , "double"+                               , "float"+                               , "int"+                               , "long"+                               , "object"+                               , "sbyte"+                               , "short"+                               , "string"+                               , "uint"+                               , "ulong"+                               , "ushort"+                               , "void"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren =+                          [ Rule+                              { rMatcher = AnyChar "fF"+                              , rAttribute = FloatTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = True+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren =+                          [ Rule+                              { rMatcher = StringDetect "ULL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LUL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LLU"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "UL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LU"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "U"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "L"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C#" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C#" , "Commentar 1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C#" , "Commentar 2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bpartial(?=\\s+(class|struct|interface|void))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\bpartial(?=\\s+(class|struct|interface|void))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bvar(?=\\s+\\w+\\s*=\\s*\\w+)"+                              , reCompiled =+                                  Just (compileRegex True "\\bvar(?=\\s+\\w+\\s*=\\s*\\w+)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\byield(?=\\s+(return|break))"+                              , reCompiled =+                                  Just (compileRegex True "\\byield(?=\\s+(return|break))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(set|get)(?=\\s*[;{])"+                              , reCompiled = Just (compileRegex True "\\b(set|get)(?=\\s*[;{])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bglobal(?=\\s*::\\s*\\w+)"+                              , reCompiled =+                                  Just (compileRegex True "\\bglobal(?=\\s*::\\s*\\w+)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#region.*$"+                              , reCompiled = Just (compileRegex True "#region.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#endregion.*$"+                              , reCompiled = Just (compileRegex True "#endregion.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[_\\w][_\\w\\d]*(?=[\\s]*[(])"+                              , reCompiled =+                                  Just (compileRegex True "\\b[_\\w][_\\w\\d]*(?=[\\s]*[(])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[.]{1,1}"+                              , reCompiled = Just (compileRegex True "[.]{1,1}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "C#" , "Member" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar ":!%&()+,-/.*<=>?[]|~^;"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "C#"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = ""+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.cs" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Css.hs view
@@ -0,0 +1,2700 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Css (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "CSS"+  , sFilename = "css.xml"+  , sShortname = "Css"+  , sContexts =+      fromList+        [ ( "Base"+          , Context+              { cName = "Base"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "FindRuleSets" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindComments"+          , Context+              { cName = "FindComments"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/\\*BEGIN.*\\*/"+                              , reCompiled = Just (compileRegex True "/\\*BEGIN.*\\*/")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/\\*END.*\\*/"+                              , reCompiled = Just (compileRegex True "/\\*END.*\\*/")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CSS" , "Comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindRuleSets"+          , Context+              { cName = "FindRuleSets"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@media\\b"+                              , reCompiled = Just (compileRegex True "@media\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CSS" , "Media" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@import\\b"+                              , reCompiled = Just (compileRegex True "@import\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CSS" , "Import" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@(font-face|charset)\\b"+                              , reCompiled = Just (compileRegex True "@(font-face|charset)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CSS" , "RuleSet" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CSS" , "SelAttr" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "#(-)?([_a-zA-Z]|(\\\\[0-9a-fA-F]{1,6})|(\\\\[^\\n\\r\\f0-9a-fA-F]))([_a-zA-Z0-9-]|(\\\\[0-9a-fA-F]{1,6})|(\\\\[^\\n\\r\\f0-9a-fA-F]))*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "#(-)?([_a-zA-Z]|(\\\\[0-9a-fA-F]{1,6})|(\\\\[^\\n\\r\\f0-9a-fA-F]))([_a-zA-Z0-9-]|(\\\\[0-9a-fA-F]{1,6})|(\\\\[^\\n\\r\\f0-9a-fA-F]))*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\.([a-zA-Z0-9\\-_]|[\\x80-\\xFF]|\\\\[0-9A-Fa-f]{1,6})*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\.([a-zA-Z0-9\\-_]|[\\x80-\\xFF]|\\\\[0-9A-Fa-f]{1,6})*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ":lang\\([\\w_-]+\\)"+                              , reCompiled = Just (compileRegex True ":lang\\([\\w_-]+\\)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CSS" , "SelPseudo" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "FindComments" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindStrings"+          , Context+              { cName = "FindStrings"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CSS" , "StringDQ" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CSS" , "StringSQ" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindValues"+          , Context+              { cName = "FindValues"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "[-+]?[0-9.]+(em|ex|ch|rem|vw|vh|vm|px|in|cm|mm|pt|pc|deg|rad|grad|turn|ms|s|Hz|kHz)\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "[-+]?[0-9.]+(em|ex|ch|rem|vw|vh|vm|px|in|cm|mm|pt|pc|deg|rad|grad|turn|ms|s|Hz|kHz)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[-+]?[0-9.]+[%]?"+                              , reCompiled = Just (compileRegex True "[-+]?[0-9.]+[%]?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\w\\-]+"+                              , reCompiled = Just (compileRegex True "[\\w\\-]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Import"+          , Context+              { cName = "Import"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "all"+                               , "aural"+                               , "braille"+                               , "embossed"+                               , "handheld"+                               , "print"+                               , "projection"+                               , "screen"+                               , "speech"+                               , "tty"+                               , "tv"+                               ])+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "FindValues" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "FindComments" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "InsideString"+          , Context+              { cName = "InsideString"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[\"']"+                              , reCompiled = Just (compileRegex True "\\\\[\"']")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MQEE"+          , Context+              { cName = "MQEE"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "FindComments" )+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CSS" , "MQEV" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\)\\s+and\\s+\\("+                              , reCompiled = Just (compileRegex True "\\)\\s+and\\s+\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = DecValTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "MQEV"+          , Context+              { cName = "MQEV"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[1-9][0-9.]*\\s*/\\s*[1-9][0-9.]*"+                              , reCompiled =+                                  Just (compileRegex True "[1-9][0-9.]*\\s*/\\s*[1-9][0-9.]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "[0-9.]+(em|ex|ch|rem|vw|vh|vm|px|in|cm|mm|pt|pc|deg|rad|grad|turn|ms|s|Hz|kHz|dpi|dpcm)\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "[0-9.]+(em|ex|ch|rem|vw|vh|vm|px|in|cm|mm|pt|pc|deg|rad|grad|turn|ms|s|Hz|kHz|dpi|dpcm)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[0-9.]+[%]?"+                              , reCompiled = Just (compileRegex True "[0-9.]+[%]?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(portrait|landscape)"+                              , reCompiled = Just (compileRegex True "(portrait|landscape)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ".*"+                              , reCompiled = Just (compileRegex True ".*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DecValTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Media"+          , Context+              { cName = "Media"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CSS" , "Media2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CSS" , "MediaQueryExpression" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "all"+                               , "aural"+                               , "braille"+                               , "embossed"+                               , "handheld"+                               , "print"+                               , "projection"+                               , "screen"+                               , "speech"+                               , "tty"+                               , "tv"+                               ])+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CSS" , "MediaQueries" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet False [ "not" , "only" ])+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CSS" , "MediaTypes" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "FindComments" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S+"+                              , reCompiled = Just (compileRegex True "\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Media2"+          , Context+              { cName = "Media2"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "FindRuleSets" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MediaQueries"+          , Context+              { cName = "MediaQueries"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+and\\s+\\("+                              , reCompiled = Just (compileRegex True "\\s+and\\s+\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CSS" , "MediaQueryExpression" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "FindComments" )+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S+"+                              , reCompiled = Just (compileRegex True "\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DecValTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MediaQueryExpression"+          , Context+              { cName = "MediaQueryExpression"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "aspect-ratio"+                               , "color"+                               , "color-index"+                               , "device-aspect-ratio"+                               , "device-height"+                               , "device-width"+                               , "grid"+                               , "height"+                               , "max-aspect-ratio"+                               , "max-color"+                               , "max-color-index"+                               , "max-device-aspect-ratio"+                               , "max-device-height"+                               , "max-device-width"+                               , "max-height"+                               , "max-monochrome"+                               , "max-resolution"+                               , "max-width"+                               , "min-aspect-ratio"+                               , "min-color"+                               , "min-color-index"+                               , "min-device-aspect-ratio"+                               , "min-device-height"+                               , "min-device-width"+                               , "min-height"+                               , "min-monochrome"+                               , "min-resolution"+                               , "min-width"+                               , "monochrome"+                               , "orientation"+                               , "resolution"+                               , "scan"+                               , "width"+                               ])+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CSS" , "MQEE" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "FindComments" )+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S+"+                              , reCompiled = Just (compileRegex True "\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DecValTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MediaTypes"+          , Context+              { cName = "MediaTypes"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "all"+                               , "aural"+                               , "braille"+                               , "embossed"+                               , "handheld"+                               , "print"+                               , "projection"+                               , "screen"+                               , "speech"+                               , "tty"+                               , "tv"+                               ])+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CSS" , "MediaQueries" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "FindComments" )+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S+"+                              , reCompiled = Just (compileRegex True "\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DecValTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "PropParen"+          , Context+              { cName = "PropParen"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CSS" , "PropParen2" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "FindComments" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "PropParen2"+          , Context+              { cName = "PropParen2"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "FindValues" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "FindComments" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Rule"+          , Context+              { cName = "Rule"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CSS" , "Rule2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Rule2"+          , Context+              { cName = "Rule2"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "-epub-hyphens"+                               , "100"+                               , "200"+                               , "300"+                               , "400"+                               , "500"+                               , "600"+                               , "700"+                               , "800"+                               , "900"+                               , "above"+                               , "absolute"+                               , "always"+                               , "armenian"+                               , "auto"+                               , "avoid"+                               , "baseline"+                               , "below"+                               , "bidi-override"+                               , "blink"+                               , "block"+                               , "bold"+                               , "bolder"+                               , "border-box"+                               , "both"+                               , "bottom"+                               , "box"+                               , "break"+                               , "capitalize"+                               , "caption"+                               , "center"+                               , "circle"+                               , "cjk-ideographic"+                               , "clip"+                               , "close-quote"+                               , "collapse"+                               , "compact"+                               , "condensed"+                               , "content-box"+                               , "crop"+                               , "cross"+                               , "crosshair"+                               , "cursive"+                               , "dashed"+                               , "decimal"+                               , "decimal-leading-zero"+                               , "default"+                               , "disc"+                               , "dotted"+                               , "double"+                               , "e-resize"+                               , "ellipsis"+                               , "ellipsis-word"+                               , "embed"+                               , "expanded"+                               , "extra-condensed"+                               , "extra-expanded"+                               , "fantasy"+                               , "fixed"+                               , "georgian"+                               , "groove"+                               , "hand"+                               , "hebrew"+                               , "help"+                               , "hidden"+                               , "hide"+                               , "higher"+                               , "hiragana"+                               , "hiragana-iroha"+                               , "icon"+                               , "inherit"+                               , "inline"+                               , "inline-block"+                               , "inline-table"+                               , "inset"+                               , "inside"+                               , "invert"+                               , "italic"+                               , "justify"+                               , "katakana"+                               , "katakana-iroha"+                               , "konq-center"+                               , "landscape"+                               , "large"+                               , "larger"+                               , "left"+                               , "level"+                               , "light"+                               , "lighter"+                               , "line-through"+                               , "list-item"+                               , "loud"+                               , "lower"+                               , "lower-alpha"+                               , "lower-greek"+                               , "lower-latin"+                               , "lower-roman"+                               , "lowercase"+                               , "ltr"+                               , "marker"+                               , "medium"+                               , "menu"+                               , "message-box"+                               , "middle"+                               , "mix"+                               , "monospace"+                               , "move"+                               , "n-resize"+                               , "narrower"+                               , "ne-resize"+                               , "no-close-quote"+                               , "no-open-quote"+                               , "no-repeat"+                               , "none"+                               , "normal"+                               , "nowrap"+                               , "nw-resize"+                               , "oblique"+                               , "open-quote"+                               , "outset"+                               , "outside"+                               , "overline"+                               , "pointer"+                               , "portrait"+                               , "pre"+                               , "pre-line"+                               , "pre-wrap"+                               , "relative"+                               , "repeat"+                               , "repeat-x"+                               , "repeat-y"+                               , "ridge"+                               , "right"+                               , "rtl"+                               , "run-in"+                               , "s-resize"+                               , "sans-serif"+                               , "scroll"+                               , "se-resize"+                               , "semi-condensed"+                               , "semi-expanded"+                               , "separate"+                               , "serif"+                               , "show"+                               , "small"+                               , "small-caps"+                               , "small-caption"+                               , "smaller"+                               , "solid"+                               , "square"+                               , "static"+                               , "static-position"+                               , "status-bar"+                               , "sub"+                               , "super"+                               , "sw-resize"+                               , "table"+                               , "table-caption"+                               , "table-cell"+                               , "table-column"+                               , "table-column-group"+                               , "table-footer-group"+                               , "table-header-group"+                               , "table-row"+                               , "table-row-group"+                               , "text"+                               , "text-bottom"+                               , "text-top"+                               , "thick"+                               , "thin"+                               , "top"+                               , "transparent"+                               , "ultra-condensed"+                               , "ultra-expanded"+                               , "underline"+                               , "upper-alpha"+                               , "upper-latin"+                               , "upper-roman"+                               , "uppercase"+                               , "visible"+                               , "w-resize"+                               , "wait"+                               , "wider"+                               , "x-large"+                               , "x-small"+                               , "xx-large"+                               , "xx-small"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "ActiveBorder"+                               , "ActiveCaption"+                               , "AppWorkspace"+                               , "aqua"+                               , "Background"+                               , "black"+                               , "blue"+                               , "ButtonFace"+                               , "ButtonHighlight"+                               , "ButtonShadow"+                               , "ButtonText"+                               , "CaptionText"+                               , "cyan"+                               , "fuchsia"+                               , "gray"+                               , "GrayText"+                               , "green"+                               , "Highlight"+                               , "HighlightText"+                               , "InactiveBorder"+                               , "InactiveCaption"+                               , "InactiveCaptionText"+                               , "InfoBackground"+                               , "InfoText"+                               , "lime"+                               , "maroon"+                               , "Menu"+                               , "MenuText"+                               , "navy"+                               , "olive"+                               , "purple"+                               , "red"+                               , "Scrollbar"+                               , "silver"+                               , "teal"+                               , "ThreeDDarkShadow"+                               , "ThreeDFace"+                               , "ThreeDHighlight"+                               , "ThreeDLightShadow"+                               , "ThreeDShadow"+                               , "white"+                               , "Window"+                               , "WindowFrame"+                               , "WindowText"+                               , "yellow"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#([0-9A-Fa-f]{3}){1,4}\\b"+                              , reCompiled = Just (compileRegex True "#([0-9A-Fa-f]{3}){1,4}\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "attr"+                               , "counter"+                               , "counters"+                               , "expression"+                               , "format"+                               , "hsl"+                               , "hsla"+                               , "local"+                               , "rect"+                               , "rgb"+                               , "rgba"+                               , "url"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CSS" , "PropParen" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "!important\\b"+                              , reCompiled = Just (compileRegex True "!important\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "FindValues" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "FindComments" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RuleSet"+          , Context+              { cName = "RuleSet"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "-khtml-background-size"+                               , "-khtml-border-bottom-left-radius"+                               , "-khtml-border-bottom-right-radius"+                               , "-khtml-border-radius"+                               , "-khtml-border-top-left-radius"+                               , "-khtml-border-top-right-radius"+                               , "-khtml-box-shadow"+                               , "-khtml-opacity"+                               , "-moz-animation-delay"+                               , "-moz-animation-direction"+                               , "-moz-animation-duration"+                               , "-moz-animation-fill-mode"+                               , "-moz-animation-iteration"+                               , "-moz-animation-name"+                               , "-moz-animation-play-state"+                               , "-moz-background-size"+                               , "-moz-border-bottom-colors"+                               , "-moz-border-image"+                               , "-moz-border-left-colors"+                               , "-moz-border-radius"+                               , "-moz-border-radius-bottomleft"+                               , "-moz-border-radius-bottomright"+                               , "-moz-border-radius-topleft"+                               , "-moz-border-radius-topright"+                               , "-moz-border-right-colors"+                               , "-moz-border-top-colors"+                               , "-moz-box"+                               , "-moz-box-flex"+                               , "-moz-box-shadow"+                               , "-moz-box-sizing"+                               , "-moz-column-count"+                               , "-moz-column-gap"+                               , "-moz-hyphens"+                               , "-moz-linear-gradient"+                               , "-moz-opacity"+                               , "-moz-outline-style"+                               , "-moz-perspective"+                               , "-moz-radial-gradient"+                               , "-moz-resize"+                               , "-moz-transform"+                               , "-moz-transform-origin"+                               , "-moz-transform-style"+                               , "-moz-transition"+                               , "-moz-transition-duration"+                               , "-moz-transition-property"+                               , "-ms-animation-delay"+                               , "-ms-animation-direction"+                               , "-ms-animation-duration"+                               , "-ms-animation-fill-mode"+                               , "-ms-animation-iteration"+                               , "-ms-animation-name"+                               , "-ms-animation-play-state"+                               , "-ms-box-sizing"+                               , "-ms-filter"+                               , "-ms-interpolation-mode"+                               , "-ms-linear-gradient"+                               , "-ms-text-size-adjust"+                               , "-ms-transform"+                               , "-ms-transition"+                               , "-o-background-size"+                               , "-o-linear-gradient"+                               , "-o-text-overflow"+                               , "-o-transform-origin"+                               , "-o-transition"+                               , "-webkit-animation-delay"+                               , "-webkit-animation-direction"+                               , "-webkit-animation-duration"+                               , "-webkit-animation-fill-mode"+                               , "-webkit-animation-iteration"+                               , "-webkit-animation-name"+                               , "-webkit-animation-play-state"+                               , "-webkit-appearance"+                               , "-webkit-background-size"+                               , "-webkit-border-bottom-colors"+                               , "-webkit-border-bottom-left-radius"+                               , "-webkit-border-bottom-right-radius"+                               , "-webkit-border-image"+                               , "-webkit-border-left-colors"+                               , "-webkit-border-radius"+                               , "-webkit-border-radius-bottomleft"+                               , "-webkit-border-radius-bottomright"+                               , "-webkit-border-right-colors"+                               , "-webkit-border-top-colors"+                               , "-webkit-border-top-left-radius"+                               , "-webkit-border-top-right-radius"+                               , "-webkit-box-flex"+                               , "-webkit-box-reflect"+                               , "-webkit-box-shadow"+                               , "-webkit-box-sizing"+                               , "-webkit-column-count"+                               , "-webkit-column-gap"+                               , "-webkit-gradient"+                               , "-webkit-hyphens"+                               , "-webkit-linear-gradient"+                               , "-webkit-perspective"+                               , "-webkit-text-fill-color"+                               , "-webkit-text-size-adjust"+                               , "-webkit-text-stroke-color"+                               , "-webkit-text-stroke-width"+                               , "-webkit-transform"+                               , "-webkit-transform-origin"+                               , "-webkit-transform-style"+                               , "-webkit-transition"+                               , "-webkit-transition-duration"+                               , "-webkit-transition-property"+                               , "align-content"+                               , "align-items"+                               , "align-self"+                               , "alignment-baseline"+                               , "all"+                               , "animation-delay"+                               , "animation-direction"+                               , "animation-duration"+                               , "animation-fill-mode"+                               , "animation-iteration-count"+                               , "animation-name"+                               , "animation-play-state"+                               , "animation-timing-function"+                               , "ascent"+                               , "azimuth"+                               , "backface-visibility"+                               , "background"+                               , "background-attachment"+                               , "background-blend-mode"+                               , "background-break"+                               , "background-clip"+                               , "background-color"+                               , "background-image"+                               , "background-origin"+                               , "background-position"+                               , "background-repeat"+                               , "background-size"+                               , "baseline"+                               , "baseline-shift"+                               , "bbox"+                               , "bookmark-label"+                               , "bookmark-level"+                               , "border"+                               , "border-bottom"+                               , "border-bottom-color"+                               , "border-bottom-image"+                               , "border-bottom-left-image"+                               , "border-bottom-left-radius"+                               , "border-bottom-right-image"+                               , "border-bottom-right-radius"+                               , "border-bottom-style"+                               , "border-bottom-width"+                               , "border-boundary"+                               , "border-collapse"+                               , "border-color"+                               , "border-corner-image"+                               , "border-image"+                               , "border-image-outset"+                               , "border-image-repeat"+                               , "border-image-slice"+                               , "border-image-source"+                               , "border-image-width"+                               , "border-left"+                               , "border-left-color"+                               , "border-left-image"+                               , "border-left-style"+                               , "border-left-width"+                               , "border-radius"+                               , "border-right"+                               , "border-right-color"+                               , "border-right-image"+                               , "border-right-style"+                               , "border-right-width"+                               , "border-spacing"+                               , "border-style"+                               , "border-top"+                               , "border-top-color"+                               , "border-top-image"+                               , "border-top-left-image"+                               , "border-top-left-radius"+                               , "border-top-right-image"+                               , "border-top-right-radius"+                               , "border-top-style"+                               , "border-top-width"+                               , "border-width"+                               , "bottom"+                               , "box-align"+                               , "box-decoration-break"+                               , "box-direction"+                               , "box-flex"+                               , "box-shadow"+                               , "box-sizing"+                               , "box-snap"+                               , "box-suppress"+                               , "break-after"+                               , "break-before"+                               , "break-inside"+                               , "cap-height"+                               , "caption-side"+                               , "caret-color"+                               , "centerline"+                               , "chains"+                               , "clear"+                               , "clip"+                               , "clip-path"+                               , "clip-rule"+                               , "color"+                               , "color-interpolation-filters"+                               , "column-count"+                               , "column-fill"+                               , "column-gap"+                               , "column-rule"+                               , "column-rule-color"+                               , "column-rule-style"+                               , "column-rule-width"+                               , "column-span"+                               , "column-width"+                               , "columns"+                               , "content"+                               , "counter-increment"+                               , "counter-reset"+                               , "counter-set"+                               , "cue"+                               , "cue-after"+                               , "cue-before"+                               , "cursor"+                               , "definition-src"+                               , "descent"+                               , "direction"+                               , "display"+                               , "dominant-baseline"+                               , "elevation"+                               , "empty-cells"+                               , "filter"+                               , "flex"+                               , "flex-basis"+                               , "flex-direction"+                               , "flex-flow"+                               , "flex-grow"+                               , "flex-shrink"+                               , "flex-wrap"+                               , "float"+                               , "flood-color"+                               , "flood-opacity"+                               , "flow"+                               , "flow-from"+                               , "flow-into"+                               , "font"+                               , "font-family"+                               , "font-feature-settings"+                               , "font-kerning"+                               , "font-language-override"+                               , "font-size"+                               , "font-size-adjust"+                               , "font-stretch"+                               , "font-style"+                               , "font-synthesis"+                               , "font-variant"+                               , "font-variant-alternates"+                               , "font-variant-caps"+                               , "font-variant-east-asian"+                               , "font-variant-ligatures"+                               , "font-variant-numeric"+                               , "font-variant-position"+                               , "font-weight"+                               , "footnote-display"+                               , "footnote-policy"+                               , "glyph-orientation-vertical"+                               , "grid"+                               , "grid-area"+                               , "grid-auto-columns"+                               , "grid-auto-flow"+                               , "grid-auto-rows"+                               , "grid-column"+                               , "grid-column-end"+                               , "grid-column-gap"+                               , "grid-column-start"+                               , "grid-gap"+                               , "grid-row"+                               , "grid-row-end"+                               , "grid-row-gap"+                               , "grid-row-start"+                               , "grid-template"+                               , "grid-template-areas"+                               , "grid-template-columns"+                               , "grid-template-rows"+                               , "hanging-punctuation"+                               , "height"+                               , "hyphens"+                               , "image-orientation"+                               , "image-rendering"+                               , "image-resolution"+                               , "initial-letter"+                               , "initial-letter-align"+                               , "initial-letter-wrap"+                               , "isolation"+                               , "justify-content"+                               , "justify-items"+                               , "justify-self"+                               , "konq_bgpos_x"+                               , "konq_bgpos_y"+                               , "left"+                               , "letter-spacing"+                               , "lighting-color"+                               , "line-grid"+                               , "line-height"+                               , "line-snap"+                               , "linear-gradient"+                               , "list-style"+                               , "list-style-image"+                               , "list-style-keyword"+                               , "list-style-position"+                               , "list-style-type"+                               , "margin"+                               , "margin-bottom"+                               , "margin-left"+                               , "margin-right"+                               , "margin-top"+                               , "marker-offset"+                               , "marker-side"+                               , "marquee-direction"+                               , "marquee-loop"+                               , "marquee-speed"+                               , "marquee-style"+                               , "mask"+                               , "mask-border"+                               , "mask-border-mode"+                               , "mask-border-outset"+                               , "mask-border-repeat"+                               , "mask-border-slice"+                               , "mask-border-source"+                               , "mask-border-width"+                               , "mask-clip"+                               , "mask-composite"+                               , "mask-image"+                               , "mask-mode"+                               , "mask-origin"+                               , "mask-position"+                               , "mask-repeat"+                               , "mask-size"+                               , "mask-type"+                               , "mathline"+                               , "max-height"+                               , "max-lines"+                               , "max-width"+                               , "min-height"+                               , "min-width"+                               , "mix-blend-mode"+                               , "nav-down"+                               , "nav-left"+                               , "nav-right"+                               , "nav-up"+                               , "object-fit"+                               , "object-position"+                               , "offset-after"+                               , "offset-before"+                               , "offset-end"+                               , "offset-start"+                               , "opacity"+                               , "order"+                               , "orphans"+                               , "outline"+                               , "outline-color"+                               , "outline-offset"+                               , "outline-style"+                               , "outline-width"+                               , "overflow"+                               , "overflow-style"+                               , "overflow-wrap"+                               , "overflow-x"+                               , "overflow-y"+                               , "padding"+                               , "padding-bottom"+                               , "padding-left"+                               , "padding-right"+                               , "padding-top"+                               , "page"+                               , "page-break-after"+                               , "page-break-before"+                               , "page-break-inside"+                               , "panose-1"+                               , "pause"+                               , "pause-after"+                               , "pause-before"+                               , "perspective"+                               , "perspective-origin"+                               , "pitch"+                               , "pitch-range"+                               , "play-during"+                               , "pointer-events"+                               , "polar-anchor"+                               , "polar-angle"+                               , "polar-distance"+                               , "polar-origin"+                               , "position"+                               , "presentation-level"+                               , "quotes"+                               , "resize"+                               , "rest"+                               , "rest-after"+                               , "rest-before"+                               , "richness"+                               , "right"+                               , "rotation"+                               , "rotation-point"+                               , "ruby-align"+                               , "ruby-merge"+                               , "ruby-position"+                               , "running"+                               , "scroll-behavior"+                               , "scroll-snap-align"+                               , "scroll-snap-margin"+                               , "scroll-snap-margin-block"+                               , "scroll-snap-margin-block-end"+                               , "scroll-snap-margin-block-start"+                               , "scroll-snap-margin-bottom"+                               , "scroll-snap-margin-inline"+                               , "scroll-snap-margin-inline-end"+                               , "scroll-snap-margin-inline-start"+                               , "scroll-snap-margin-left"+                               , "scroll-snap-margin-right"+                               , "scroll-snap-margin-top"+                               , "scroll-snap-padding"+                               , "scroll-snap-padding-block"+                               , "scroll-snap-padding-block-end"+                               , "scroll-snap-padding-block-start"+                               , "scroll-snap-padding-bottom"+                               , "scroll-snap-padding-inline"+                               , "scroll-snap-padding-inline-end"+                               , "scroll-snap-padding-inline-start"+                               , "scroll-snap-padding-left"+                               , "scroll-snap-padding-right"+                               , "scroll-snap-padding-top"+                               , "scroll-snap-stop"+                               , "scroll-snap-type"+                               , "shape-image-threshold"+                               , "shape-inside"+                               , "shape-margin"+                               , "shape-outside"+                               , "size"+                               , "slope"+                               , "speak"+                               , "speak-as"+                               , "speak-header"+                               , "speak-numeral"+                               , "speak-punctuation"+                               , "speech-rate"+                               , "src"+                               , "stemh"+                               , "stemv"+                               , "stress"+                               , "string-set"+                               , "tab-size"+                               , "table-layout"+                               , "text-align"+                               , "text-align-last"+                               , "text-combine-upright"+                               , "text-decoration"+                               , "text-decoration-color"+                               , "text-decoration-line"+                               , "text-decoration-skip"+                               , "text-decoration-style"+                               , "text-emphasis"+                               , "text-emphasis-color"+                               , "text-emphasis-position"+                               , "text-emphasis-style"+                               , "text-indent"+                               , "text-justify"+                               , "text-orientation"+                               , "text-overflow"+                               , "text-shadow"+                               , "text-transform"+                               , "text-underline-position"+                               , "text-wrap"+                               , "top"+                               , "topline"+                               , "transform"+                               , "transform-origin"+                               , "transform-style"+                               , "transition"+                               , "transition-delay"+                               , "transition-duration"+                               , "transition-property"+                               , "transition-timing-function"+                               , "unicode-bidi"+                               , "unicode-range"+                               , "units-per-em"+                               , "vertical-align"+                               , "visibility"+                               , "voice-balance"+                               , "voice-duration"+                               , "voice-family"+                               , "voice-pitch"+                               , "voice-range"+                               , "voice-rate"+                               , "voice-stress"+                               , "voice-volume"+                               , "volume"+                               , "white-space"+                               , "widows"+                               , "width"+                               , "widths"+                               , "will-change"+                               , "word-break"+                               , "word-spacing"+                               , "word-wrap"+                               , "wrap-flow"+                               , "wrap-through"+                               , "writing-mode"+                               , "x-height"+                               , "z-index"+                               , "zoom"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CSS" , "Rule" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-?[A-Za-z_-]+(?=\\s*:)"+                              , reCompiled = Just (compileRegex True "-?[A-Za-z_-]+(?=\\s*:)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "CSS" , "Rule" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "FindComments" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SelAttr"+          , Context+              { cName = "SelAttr"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "FindStrings" )+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = AttributeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SelPseudo"+          , Context+              { cName = "SelPseudo"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "active"+                               , "after"+                               , "before"+                               , "checked"+                               , "disabled"+                               , "empty"+                               , "enabled"+                               , "first-child"+                               , "first-letter"+                               , "first-line"+                               , "first-of-type"+                               , "focus"+                               , "hover"+                               , "indeterminate"+                               , "last-child"+                               , "last-of-type"+                               , "link"+                               , "not"+                               , "nth-child"+                               , "nth-last-child"+                               , "nth-last-of-type"+                               , "nth-of-type"+                               , "only-child"+                               , "only-of-type"+                               , "root"+                               , "selection"+                               , "target"+                               , "visited"+                               ])+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = DecValTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "StringDQ"+          , Context+              { cName = "StringDQ"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "InsideString" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "StringSQ"+          , Context+              { cName = "StringSQ"+              , cSyntax = "CSS"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "InsideString" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Wilbert Berendsen (wilbert@kde.nl)"+  , sVersion = "3"+  , sLicense = "LGPL"+  , sExtensions = [ "*.css" ]+  , sStartingContext = "Base"+  }
+ src/Skylighting/Syntax/Curry.hs view
@@ -0,0 +1,1411 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Curry (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Curry"+  , sFilename = "curry.xml"+  , sShortname = "Curry"+  , sContexts =+      fromList+        [ ( "Char"+          , Context+              { cName = "Char"+              , cSyntax = "Curry"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Curry" , "CharEscape" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^'\\\\]"+                              , reCompiled = Just (compileRegex True "[^'\\\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Curry" , "CharEnd" ) ]+                      }+                  ]+              , cAttribute = CharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Curry" , "CharSyntaxError" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CharEnd"+          , Context+              { cName = "CharEnd"+              , cSyntax = "Curry"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Push ( "Curry" , "CharSyntaxError" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CharEscape"+          , Context+              { cName = "CharEscape"+              , cSyntax = "Curry"+              , cRules =+                  [ Rule+                      { rMatcher = AnyChar "abfnrtv\\\"'"+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Curry" , "CharEnd" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "o[0-7]+"+                              , reCompiled = Just (compileRegex True "o[0-7]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Curry" , "CharEnd" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[0-9]+"+                              , reCompiled = Just (compileRegex True "[0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Curry" , "CharEnd" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "x[0-9a-fA-F]+"+                              , reCompiled = Just (compileRegex True "x[0-9a-fA-F]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Curry" , "CharEnd" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\^[A-Z@\\[\\\\\\]\\^_]"+                              , reCompiled = Just (compileRegex True "\\^[A-Z@\\[\\\\\\]\\^_]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Curry" , "CharEnd" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "NUL|SOH|STX|ETX|EOT|ENQ|ACK|BEL|BS|HT|LF|VT|FF|CR|SO|SI|DLE|DC1|DC2|DC3|DC4|NAK|SYN|ETB|CAN|EM|SUB|ESC|FS|GS|RS|US|SP|DEL"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "NUL|SOH|STX|ETX|EOT|ENQ|ACK|BEL|BS|HT|LF|VT|FF|CR|SO|SI|DLE|DC1|DC2|DC3|DC4|NAK|SYN|ETB|CAN|EM|SUB|ESC|FS|GS|RS|US|SP|DEL")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Curry" , "CharEnd" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Curry" , "CharEnd" ) ]+                      }+                  ]+              , cAttribute = CharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Push ( "Curry" , "CharSyntaxError" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CharSyntaxError"+          , Context+              { cName = "CharSyntaxError"+              , cSyntax = "Curry"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "Curry"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Currydoc"+          , Context+              { cName = "Currydoc"+              , cSyntax = "Curry"+              , cRules = []+              , cAttribute = DocumentationTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Import"+          , Context+              { cName = "Import"+              , cSyntax = "Curry"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "{-#"+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Curry" , "Pragma" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '{' '-'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Curry" , "Multiline Comment" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "---"+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Curry" , "Currydoc" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '-' '-'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Curry" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([A-Z][a-zA-Z0-9_']*\\.)*[A-Z][a-zA-Z0-9_']*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "([A-Z][a-zA-Z0-9_']*\\.)*[A-Z][a-zA-Z0-9_']*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars 'a' 's'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "hiding"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S+"+                              , reCompiled = Just (compileRegex True "\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Infix"+          , Context+              { cName = "Infix"+              , cSyntax = "Curry"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Multiline Comment"+          , Context+              { cName = "Multiline Comment"+              , cSyntax = "Curry"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '-' '}'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Curry"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "{-#"+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Curry" , "Pragma" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '{' '-'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Curry" , "Multiline Comment" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "---"+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Curry" , "Currydoc" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '-' '-'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Curry" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "case"+                               , "data"+                               , "do"+                               , "else"+                               , "external"+                               , "fcase"+                               , "free"+                               , "if"+                               , "in"+                               , "infix"+                               , "infixl"+                               , "infixr"+                               , "let"+                               , "module"+                               , "of"+                               , "then"+                               , "type"+                               , "where"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "all"+                               , "and"+                               , "any"+                               , "appendFile"+                               , "best"+                               , "break"+                               , "browse"+                               , "browseList"+                               , "chr"+                               , "concat"+                               , "concatMap"+                               , "const"+                               , "curry"+                               , "div"+                               , "doSolve"+                               , "done"+                               , "drop"+                               , "dropWhile"+                               , "either"+                               , "elem"+                               , "ensureNotFree"+                               , "ensureSpine"+                               , "enumFrom"+                               , "enumFromThen"+                               , "enumFromThenTo"+                               , "enumFromTo"+                               , "error"+                               , "failed"+                               , "filter"+                               , "findall"+                               , "flip"+                               , "foldl"+                               , "foldl1"+                               , "foldr"+                               , "foldr1"+                               , "fst"+                               , "getChar"+                               , "getLine"+                               , "head"+                               , "id"+                               , "if_then_else"+                               , "iterate"+                               , "length"+                               , "lines"+                               , "lookup"+                               , "map"+                               , "mapIO"+                               , "mapIO_"+                               , "max"+                               , "maybe"+                               , "min"+                               , "mod"+                               , "negate"+                               , "not"+                               , "notElem"+                               , "null"+                               , "once"+                               , "or"+                               , "ord"+                               , "otherwise"+                               , "print"+                               , "putChar"+                               , "putStr"+                               , "putStrLn"+                               , "readFile"+                               , "repeat"+                               , "replicate"+                               , "return"+                               , "reverse"+                               , "seq"+                               , "sequenceIO"+                               , "sequenceIO_"+                               , "show"+                               , "snd"+                               , "solveAll"+                               , "span"+                               , "splitAt"+                               , "success"+                               , "tail"+                               , "take"+                               , "takeWhile"+                               , "try"+                               , "uncurry"+                               , "unknown"+                               , "unlines"+                               , "unpack"+                               , "until"+                               , "unwords"+                               , "unzip"+                               , "unzip3"+                               , "words"+                               , "writeFile"+                               , "zip"+                               , "zip3"+                               , "zipWith"+                               , "zipWith3"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Bool"+                               , "Char"+                               , "Either"+                               , "Float"+                               , "IO"+                               , "Int"+                               , "Maybe"+                               , "Ordering"+                               , "String"+                               , "Success"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "EQ"+                               , "False"+                               , "GT"+                               , "Just"+                               , "LT"+                               , "Left"+                               , "Nothing"+                               , "Right"+                               , "True"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "import\\s+(qualified)?"+                              , reCompiled = Just (compileRegex True "import\\s+(qualified)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Curry" , "Import" ) ]+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "0(o|O)[0-7]+"+                              , reCompiled = Just (compileRegex True "0(o|O)[0-7]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Curry" , "Char" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Curry" , "String" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(::|:=|:>|\\->|<\\-|\\.\\.)"+                              , reCompiled =+                                  Just (compileRegex True "(::|:=|:>|\\->|<\\-|\\.\\.)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\s*([a-z][a-zA-Z0-9_']*|\\([~!@#\\$%\\^&\\*\\+\\-=<>\\?\\./\\|\\\\:]+\\))\\s*(,\\s*([a-z][a-zA-Z0-9_']*|\\([~!@#\\$%\\^&\\*\\+\\-=<>\\?\\./\\|\\\\:]+\\)))*\\s*(?=::[^~!@#\\$%\\^&\\*\\+\\-=<>\\?\\./\\|\\\\:])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\s*([a-z][a-zA-Z0-9_']*|\\([~!@#\\$%\\^&\\*\\+\\-=<>\\?\\./\\|\\\\:]+\\))\\s*(,\\s*([a-z][a-zA-Z0-9_']*|\\([~!@#\\$%\\^&\\*\\+\\-=<>\\?\\./\\|\\\\:]+\\)))*\\s*(?=::[^~!@#\\$%\\^&\\*\\+\\-=<>\\?\\./\\|\\\\:])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([A-Z][a-zA-Z0-9_']*\\.)*[a-z][a-zA-Z0-9_']*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "([A-Z][a-zA-Z0-9_']*\\.)*[a-z][a-zA-Z0-9_']*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "([A-Z][a-zA-Z0-9_']*\\.)*[~!@#\\$%\\^&\\*\\+\\-=<>\\?\\./\\|\\\\:]+"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "([A-Z][a-zA-Z0-9_']*\\.)*[~!@#\\$%\\^&\\*\\+\\-=<>\\?\\./\\|\\\\:]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([A-Z][a-zA-Z0-9_']*\\.)*[A-Z][a-zA-Z0-9_']*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "([A-Z][a-zA-Z0-9_']*\\.)*[A-Z][a-zA-Z0-9_']*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Curry" , "Infix" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Pragma"+          , Context+              { cName = "Pragma"+              , cSyntax = "Curry"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "#-}"+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Curry"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Curry" , "StringEscape" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^\"\\\\]*"+                              , reCompiled = Just (compileRegex True "[^\"\\\\]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Curry" , "StringSyntaxError" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "StringEscape"+          , Context+              { cName = "StringEscape"+              , cSyntax = "Curry"+              , cRules =+                  [ Rule+                      { rMatcher = AnyChar "abfnrtv\\\"'&"+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "o[0-7]+"+                              , reCompiled = Just (compileRegex True "o[0-7]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[0-9]+"+                              , reCompiled = Just (compileRegex True "[0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "x[0-9a-fA-F]+"+                              , reCompiled = Just (compileRegex True "x[0-9a-fA-F]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\^[A-Z@\\[\\\\\\]\\^_]"+                              , reCompiled = Just (compileRegex True "\\^[A-Z@\\[\\\\\\]\\^_]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "NUL|SOH|STX|ETX|EOT|ENQ|ACK|BEL|BS|HT|LF|VT|FF|CR|SO|SI|DLE|DC1|DC2|DC3|DC4|NAK|SYN|ETB|CAN|EM|SUB|ESC|FS|GS|RS|US|SP|DEL"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "NUL|SOH|STX|ETX|EOT|ENQ|ACK|BEL|BS|HT|LF|VT|FF|CR|SO|SI|DLE|DC1|DC2|DC3|DC4|NAK|SYN|ETB|CAN|EM|SUB|ESC|FS|GS|RS|US|SP|DEL")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Curry" , "StringGap" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Curry" , "StringGap" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "StringGap"+          , Context+              { cName = "StringGap"+              , cSyntax = "Curry"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Pop , Pop , Pop , Push ( "Curry" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "StringSyntaxError"+          , Context+              { cName = "StringSyntaxError"+              , cSyntax = "Curry"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Bj\246rn Peem\246ller (bjp@informatik.uni-kiel.de)"+  , sVersion = "1"+  , sLicense = "LGPL"+  , sExtensions = [ "*.curry" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/D.hs view
@@ -0,0 +1,3581 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.D (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "D"+  , sFilename = "d.xml"+  , sShortname = "D"+  , sContexts =+      fromList+        [ ( "BQString"+          , Context+              { cName = "BQString"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CharLiteral"+          , Context+              { cName = "CharLiteral"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "CharLiteralClosing" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(u[\\da-fA-F]{4}|U[\\da-fA-F]{8}|&[a-zA-Z]\\w+;)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\\\(u[\\da-fA-F]{4}|U[\\da-fA-F]{8}|&[a-zA-Z]\\w+;)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "CharLiteralClosing" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "CharLiteralClosing" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "CharLiteralClosing" ) ]+                      }+                  ]+              , cAttribute = CharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "D" , "CharLiteralClosing" ) ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "CharLiteralClosing"+          , Context+              { cName = "CharLiteralClosing"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop , Pop ]+              , cDynamic = False+              }+          )+        , ( "CommentBlock"+          , Context+              { cName = "CommentBlock"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CommentLine"+          , Context+              { cName = "CommentLine"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CommentNested"+          , Context+              { cName = "CommentNested"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '+'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "CommentNested" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '+' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CommentRules"+          , Context+              { cName = "CommentRules"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "D" , "DdocNormal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "CommentLine" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "CommentBlock" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '+'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "CommentNested" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DdocBlock"+          , Context+              { cName = "DdocBlock"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\*+/"+                              , reCompiled = Just (compileRegex True "\\*+/")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '('+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "DdocMacro" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\w_]+:($|\\s)"+                              , reCompiled = Just (compileRegex True "[\\w_]+:($|\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^-]-{3,}"+                              , reCompiled = Just (compileRegex True "[^-]-{3,}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-{3,}($|\\s)"+                              , reCompiled = Just (compileRegex True "-{3,}($|\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "DdocBlockCode" ) ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DdocBlockCode"+          , Context+              { cName = "DdocBlockCode"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\*+/"+                              , reCompiled = Just (compileRegex True "\\*+/")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^-]-{3,}"+                              , reCompiled = Just (compileRegex True "[^-]-{3,}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-{3,}($|\\s)"+                              , reCompiled = Just (compileRegex True "-{3,}($|\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "D" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DdocLine"+          , Context+              { cName = "DdocLine"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '('+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "DdocMacro" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\w_]+:($|\\s)"+                              , reCompiled = Just (compileRegex True "[\\w_]+:($|\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DdocMacro"+          , Context+              { cName = "DdocMacro"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "D" , "MacroRules" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "DdocMacro2" ) ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DdocMacro2"+          , Context+              { cName = "DdocMacro2"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "D" , "MacroRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DdocMacro3"+          , Context+              { cName = "DdocMacro3"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "D" , "MacroRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DdocNested"+          , Context+              { cName = "DdocNested"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '+'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "DdocNested2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\++/"+                              , reCompiled = Just (compileRegex True "\\++/")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '+'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '('+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "DdocMacro" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\w_]+:($|\\s)"+                              , reCompiled = Just (compileRegex True "[\\w_]+:($|\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^-]-{3,}"+                              , reCompiled = Just (compileRegex True "[^-]-{3,}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-{3,}($|\\s)"+                              , reCompiled = Just (compileRegex True "-{3,}($|\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "DdocNestedCode" ) ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DdocNested2"+          , Context+              { cName = "DdocNested2"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\++/"+                              , reCompiled = Just (compileRegex True "\\++/")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "D" , "DdocNested" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DdocNestedCode"+          , Context+              { cName = "DdocNestedCode"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\++/"+                              , reCompiled = Just (compileRegex True "\\++/")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '+'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^-]-{3,}"+                              , reCompiled = Just (compileRegex True "[^-]-{3,}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-{3,}($|\\s)"+                              , reCompiled = Just (compileRegex True "-{3,}($|\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "D" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DdocNormal"+          , Context+              { cName = "DdocNormal"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/{3,}"+                              , reCompiled = Just (compileRegex True "/{3,}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "DdocLine" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/\\*{2,}(?!/)"+                              , reCompiled = Just (compileRegex True "/\\*{2,}(?!/)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "DdocBlock" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/\\+{2,}(?!/)"+                              , reCompiled = Just (compileRegex True "/\\+{2,}(?!/)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "DdocNested" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "HTMLEntity"+          , Context+              { cName = "HTMLEntity"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z]\\w+;"+                              , reCompiled = Just (compileRegex True "[a-zA-Z]\\w+;")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = SpecialCharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "HexString"+          , Context+              { cName = "HexString"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^\\sa-fA-F\\d\"]+"+                              , reCompiled = Just (compileRegex True "[^\\sa-fA-F\\d\"]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "LinePragma"+          , Context+              { cName = "LinePragma"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "((0([0-7_]+|[bB]_*[01][01_]*|[xX]_*[\\da-fA-F][\\da-fA-F_]*))|\\d+[\\d_]*)(L[uU]?|[uU]L?)?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "((0([0-7_]+|[bB]_*[01][01_]*|[xX]_*[\\da-fA-F][\\da-fA-F_]*))|\\d+[\\d_]*)(L[uU]?|[uU]L?)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"[^\"]*\""+                              , reCompiled = Just (compileRegex True "\"[^\"]*\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "__DATE__"+                               , "__EOF__"+                               , "__FILE__"+                               , "__LINE__"+                               , "__TIMESTAMP__"+                               , "__TIME__"+                               , "__VENDOR__"+                               , "__VERSION__"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "D" , "CommentRules" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ".+"+                              , reCompiled = Just (compileRegex True ".+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Linkage"+          , Context+              { cName = "Linkage"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "Linkage2" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "D" , "CommentRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "Linkage2"+          , Context+              { cName = "Linkage2"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "C++"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "C" , "D" , "Pascal" , "System" , "Windows" ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "D" , "CommentRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^)\\s\\n]+"+                              , reCompiled = Just (compileRegex True "[^)\\s\\n]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MacroRules"+          , Context+              { cName = "MacroRules"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '$' '('+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "DdocMacro" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "DdocMacro3" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ModuleName"+          , Context+              { cName = "ModuleName"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "D" , "CommentRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^\\s\\w.:,=]"+                              , reCompiled = Just (compileRegex True "[^\\s\\w.:,=]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "NumberLiteral"+          , Context+              { cName = "NumberLiteral"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "0[xX][\\da-fA-F_]*(\\.[\\da-fA-F_]*)?[pP][-+]?\\d[\\d_]*[fFL]?i?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "0[xX][\\da-fA-F_]*(\\.[\\da-fA-F_]*)?[pP][-+]?\\d[\\d_]*[fFL]?i?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\d[_\\d]*(\\.(?!\\.)[_\\d]*([eE][-+]?\\d[_\\d]*)?[fFL]?i?|[eE][-+]?\\d[_\\d]*[fFL]?i?|[fF]i?|[fFL]?i)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\d[_\\d]*(\\.(?!\\.)[_\\d]*([eE][-+]?\\d[_\\d]*)?[fFL]?i?|[eE][-+]?\\d[_\\d]*[fFL]?i?|[fF]i?|[fFL]?i)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "0[bB]_*[01][01_]*(L[uU]?|[uU]L?)?"+                              , reCompiled =+                                  Just (compileRegex True "0[bB]_*[01][01_]*(L[uU]?|[uU]L?)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "0[0-7_]+(L[uU]?|[uU]L?)?"+                              , reCompiled = Just (compileRegex True "0[0-7_]+(L[uU]?|[uU]L?)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "0[xX]_*[\\da-fA-F][\\da-fA-F_]*(L[uU]?|[uU]L?)?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "0[xX]_*[\\da-fA-F][\\da-fA-F_]*(L[uU]?|[uU]L?)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\d+[\\d_]*(L[uU]?|[uU]L?)?"+                              , reCompiled =+                                  Just (compileRegex True "\\d+[\\d_]*(L[uU]?|[uU]L?)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "Pragma"+          , Context+              { cName = "Pragma"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "Pragma2" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "D" , "CommentRules" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^\\s\\n]+"+                              , reCompiled = Just (compileRegex True "[^\\s\\n]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Pragma2"+          , Context+              { cName = "Pragma2"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "lib" , "msg" ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "D" , "CommentRules" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^)\\s\\n]+"+                              , reCompiled = Just (compileRegex True "[^)\\s\\n]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Properties"+          , Context+              { cName = "Properties"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "alignof"+                               , "dig"+                               , "dup"+                               , "epsilon"+                               , "idup"+                               , "im"+                               , "infinity"+                               , "init"+                               , "keys"+                               , "length"+                               , "mangleof"+                               , "mant_dig"+                               , "max"+                               , "max_10_exp"+                               , "max_exp"+                               , "min"+                               , "min_10_exp"+                               , "min_exp"+                               , "nan"+                               , "offsetof"+                               , "ptr"+                               , "re"+                               , "rehash"+                               , "reverse"+                               , "sizeof"+                               , "sort"+                               , "stringof"+                               , "tupleof"+                               , "values"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "RawString"+          , Context+              { cName = "RawString"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = VerbatimStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Region Marker"+          , Context+              { cName = "Region Marker"+              , cSyntax = "D"+              , cRules = []+              , cAttribute = RegionMarkerTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Scope"+          , Context+              { cName = "Scope"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "Scope2" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "D" , "CommentRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "Scope2"+          , Context+              { cName = "Scope2"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "exit" , "failure" , "success" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "D" , "CommentRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^)\\s\\n]+"+                              , reCompiled = Just (compileRegex True "[^)\\s\\n]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "StartingLetter"+          , Context+              { cName = "StartingLetter"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^a-zA-Z_]"+                              , reCompiled = Just (compileRegex True "[^a-zA-Z_]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "in\\s*(?=\\{)"+                              , reCompiled = Just (compileRegex True "in\\s*(?=\\{)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "out\\s*(?=(\\(([a-zA-Z_][\\w_]*)?\\)\\s*)?\\{)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "out\\s*(?=(\\(([a-zA-Z_][\\w_]*)?\\)\\s*)?\\{)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "scope\\s*(?=\\()"+                              , reCompiled = Just (compileRegex True "scope\\s*(?=\\()")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "Scope" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "import\\s*(?=\\()"+                              , reCompiled = Just (compileRegex True "import\\s*(?=\\()")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "function\\s*(?=\\()"+                              , reCompiled = Just (compileRegex True "function\\s*(?=\\()")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "delegate\\s*(?=\\()"+                              , reCompiled = Just (compileRegex True "delegate\\s*(?=\\()")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "asm"+                               , "body"+                               , "break"+                               , "case"+                               , "catch"+                               , "continue"+                               , "default"+                               , "do"+                               , "else"+                               , "finally"+                               , "for"+                               , "foreach"+                               , "foreach_reverse"+                               , "goto"+                               , "if"+                               , "mixin"+                               , "return"+                               , "switch"+                               , "synchronized"+                               , "throw"+                               , "try"+                               , "while"+                               , "with"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "abstract"+                               , "align"+                               , "auto"+                               , "const"+                               , "export"+                               , "final"+                               , "immutable"+                               , "inout"+                               , "invariant"+                               , "lazy"+                               , "nothrow"+                               , "out"+                               , "override"+                               , "package"+                               , "private"+                               , "protected"+                               , "public"+                               , "pure"+                               , "ref"+                               , "scope"+                               , "static"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "assert"+                               , "cast"+                               , "delegate"+                               , "delete"+                               , "false"+                               , "function"+                               , "in"+                               , "is"+                               , "new"+                               , "null"+                               , "super"+                               , "this"+                               , "true"+                               , "typeid"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "alias"+                               , "class"+                               , "enum"+                               , "interface"+                               , "struct"+                               , "typedef"+                               , "union"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "macro" , "template" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "import" , "module" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "ModuleName" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "bool"+                               , "byte"+                               , "cdouble"+                               , "cent"+                               , "cfloat"+                               , "char"+                               , "creal"+                               , "dchar"+                               , "double"+                               , "float"+                               , "idouble"+                               , "ifloat"+                               , "int"+                               , "ireal"+                               , "long"+                               , "real"+                               , "short"+                               , "typeof"+                               , "ubyte"+                               , "ucent"+                               , "uint"+                               , "ulong"+                               , "ushort"+                               , "void"+                               , "wchar"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ClassInfo"+                               , "Error"+                               , "Exception"+                               , "Interface"+                               , "ModuleInfo"+                               , "Object"+                               , "OffsetTypeInfo"+                               , "TypeInfo"+                               , "TypeInfo_Array"+                               , "TypeInfo_AssociativeArray"+                               , "TypeInfo_Class"+                               , "TypeInfo_Const"+                               , "TypeInfo_Delegate"+                               , "TypeInfo_Enum"+                               , "TypeInfo_Function"+                               , "TypeInfo_Interface"+                               , "TypeInfo_Invariant"+                               , "TypeInfo_Pointer"+                               , "TypeInfo_StaticArray"+                               , "TypeInfo_Struct"+                               , "TypeInfo_Tuple"+                               , "TypeInfo_Typedef"+                               , "bit"+                               , "dstring"+                               , "hash_t"+                               , "ptrdiff_t"+                               , "size_t"+                               , "string"+                               , "wstring"+                               ])+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "extern" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "Linkage" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "__DATE__"+                               , "__EOF__"+                               , "__FILE__"+                               , "__LINE__"+                               , "__TIMESTAMP__"+                               , "__TIME__"+                               , "__VENDOR__"+                               , "__VERSION__"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "debug" , "unittest" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "pragma" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "Pragma" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "version" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "Version" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "deprecated" , "volatile" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars 'r' '"'+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "RawString" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars 'x' '"'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "HexString" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '"' 'c'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '"' 'w'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '"' 'd'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' 'u'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "UnicodeShort" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' 'U'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "UnicodeLong" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '&'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "HTMLEntity" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "UnicodeLong"+          , Context+              { cName = "UnicodeLong"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\da-fA-F]{8}"+                              , reCompiled = Just (compileRegex True "[\\da-fA-F]{8}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = SpecialCharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "UnicodeShort"+          , Context+              { cName = "UnicodeShort"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\da-fA-F]{4}"+                              , reCompiled = Just (compileRegex True "[\\da-fA-F]{4}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = SpecialCharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Version"+          , Context+              { cName = "Version"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "Version2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "Version2" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "D" , "CommentRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^\\s\\n]+"+                              , reCompiled = Just (compileRegex True "[^\\s\\n]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Version2"+          , Context+              { cName = "Version2"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "BigEndian"+                               , "D_Coverage"+                               , "D_InlineAsm_X86"+                               , "D_Version2"+                               , "DigitalMars"+                               , "LittleEndian"+                               , "Win32"+                               , "Win64"+                               , "Windows"+                               , "X86"+                               , "X86_64"+                               , "all"+                               , "linux"+                               , "none"+                               , "unittest"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\d+[\\d_]*(L[uU]?|[uU]L?)?"+                              , reCompiled =+                                  Just (compileRegex True "\\d+[\\d_]*(L[uU]?|[uU]L?)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "D" , "CommentRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^)\\s\\n]+"+                              , reCompiled = Just (compileRegex True "[^)\\s\\n]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "normal"+          , Context+              { cName = "normal"+              , cSyntax = "D"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z_]"+                              , reCompiled = Just (compileRegex True "[a-zA-Z_]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "StartingLetter" ) ]+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' 'u'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "UnicodeShort" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' 'U'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "UnicodeLong" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '&'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "HTMLEntity" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "CharLiteral" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "BQString" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "//BEGIN"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "Region Marker" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "//END"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "Region Marker" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "D" , "CommentRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "..."+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '.' '.'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.\\d[\\d_]*([eE][-+]?\\d[\\d_]*)?[fFL]?i?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\.\\d[\\d_]*([eE][-+]?\\d[\\d_]*)?[fFL]?i?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '.'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "Properties" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\d"+                              , reCompiled = Just (compileRegex True "\\d")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "NumberLiteral" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "#line"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "D" , "LinePragma" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar ":!%&()+,-/.*<=>?[]|~^;"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor =+      "Diggory Hardy (diggory.hardy@gmail.com), Aziz K\246ksal (aziz.koeksal@gmail.com), Jari-Matti M\228kel\228 (jmjm@iki.fi), Simon J Mackenzie (project.katedxml@smackoz.fastmail.fm)"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions = [ "*.d" , "*.D" , "*.di" , "*.DI" ]+  , sStartingContext = "normal"+  }
+ src/Skylighting/Syntax/Diff.hs view
@@ -0,0 +1,815 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Diff (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex++syntax :: Syntax+syntax = Syntax+  { sName = "Diff"+  , sFilename = "diff.xml"+  , sShortname = "Diff"+  , sContexts =+      fromList+        [ ( "Added"+          , Context+              { cName = "Added"+              , cSyntax = "Diff"+              , cRules = []+              , cAttribute = VariableTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ChangedNew"+          , Context+              { cName = "ChangedNew"+              , cSyntax = "Diff"+              , cRules = []+              , cAttribute = VariableTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ChangedOld"+          , Context+              { cName = "ChangedOld"+              , cSyntax = "Diff"+              , cRules = []+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Chunk"+          , Context+              { cName = "Chunk"+              , cSyntax = "Diff"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Diff" , "FindDiff" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\@\\@|\\d).*$"+                              , reCompiled = Just (compileRegex True "(\\@\\@|\\d).*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '!'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Diff" , "ChangedOld" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ChunkInFile"+          , Context+              { cName = "ChunkInFile"+              , cSyntax = "Diff"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Diff" , "FindDiff" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\@\\@|\\d).*$"+                              , reCompiled = Just (compileRegex True "(\\@\\@|\\d).*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "Index:.*"+                              , reCompiled = Just (compileRegex True "Index:.*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(====|\\*\\*\\*|\\-\\-\\-|diff|Only in .*:).*$"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(====|\\*\\*\\*|\\-\\-\\-|diff|Only in .*:).*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '!'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Diff" , "ChangedOld" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "File"+          , Context+              { cName = "File"+              , cSyntax = "Diff"+              , cRules = []+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindDiff"+          , Context+              { cName = "FindDiff"+              , cSyntax = "Diff"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\-\\-\\-.*$"+                              , reCompiled = Just (compileRegex True "\\-\\-\\-.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\+\\+\\+|\\-\\-\\-).*$"+                              , reCompiled = Just (compileRegex True "(\\+\\+\\+|\\-\\-\\-).*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "+>"+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Diff" , "Added" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "-<"+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Diff" , "Removed" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Diff"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\@\\@|\\d).*$"+                              , reCompiled = Just (compileRegex True "(\\@\\@|\\d).*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Diff" , "Chunk" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\*+$"+                              , reCompiled = Just (compileRegex True "\\*+$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Diff" , "RChunk" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "Only in .*:.*$"+                              , reCompiled = Just (compileRegex True "Only in .*:.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "diff.*$"+                              , reCompiled = Just (compileRegex True "diff.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Diff" , "RFile" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "====.*$"+                              , reCompiled = Just (compileRegex True "====.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\*\\*\\*|\\-\\-\\-).*$"+                              , reCompiled = Just (compileRegex True "(\\*\\*\\*|\\-\\-\\-).*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Diff" , "File" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Diff" , "FindDiff" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '!'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Diff" , "ChangedOld" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RChunk"+          , Context+              { cName = "RChunk"+              , cSyntax = "Diff"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\*\\*\\* .* \\*\\*\\*\\*$"+                              , reCompiled =+                                  Just (compileRegex True "\\*\\*\\* .* \\*\\*\\*\\*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\-\\-\\- .* \\-\\-\\-\\-$"+                              , reCompiled =+                                  Just (compileRegex True "\\-\\-\\- .* \\-\\-\\-\\-$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Diff" , "RChunkNew" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Diff" , "Chunk" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RChunkInFile"+          , Context+              { cName = "RChunkInFile"+              , cSyntax = "Diff"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\*\\*\\* .* \\*\\*\\*\\*$"+                              , reCompiled =+                                  Just (compileRegex True "\\*\\*\\* .* \\*\\*\\*\\*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\-\\-\\- .* \\-\\-\\-\\-$"+                              , reCompiled =+                                  Just (compileRegex True "\\-\\-\\- .* \\-\\-\\-\\-$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Diff" , "RChunkInFileNew" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Diff" , "ChunkInFile" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RChunkInFileNew"+          , Context+              { cName = "RChunkInFileNew"+              , cSyntax = "Diff"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\@\\@|\\d).*$"+                              , reCompiled = Just (compileRegex True "(\\@\\@|\\d).*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(====|\\*\\*\\*|\\-\\-\\-|diff|Only in .*:).*$"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(====|\\*\\*\\*|\\-\\-\\-|diff|Only in .*:).*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '!'+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Diff" , "ChangedNew" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Diff" , "FindDiff" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RChunkNew"+          , Context+              { cName = "RChunkNew"+              , cSyntax = "Diff"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\@\\@|\\d).*$"+                              , reCompiled = Just (compileRegex True "(\\@\\@|\\d).*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '!'+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Diff" , "ChangedNew" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Diff" , "FindDiff" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RFile"+          , Context+              { cName = "RFile"+              , cSyntax = "Diff"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(diff|Only in .*:).*$"+                              , reCompiled = Just (compileRegex True "(diff|Only in .*:).*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(====|\\*\\*\\*|\\-\\-\\-|diff|Only in .*:).*$"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(====|\\*\\*\\*|\\-\\-\\-|diff|Only in .*:).*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\*+$"+                              , reCompiled = Just (compileRegex True "\\*+$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Diff" , "RChunkInFile" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Diff" , "File" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Removed"+          , Context+              { cName = "Removed"+              , cSyntax = "Diff"+              , cRules = []+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = ""+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.diff" , "*patch" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Djangotemplate.hs view
@@ -0,0 +1,2565 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Djangotemplate (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Django HTML Template"+  , sFilename = "djangotemplate.xml"+  , sShortname = "Djangotemplate"+  , sContexts =+      fromList+        [ ( "CDATA"+          , Context+              { cName = "CDATA"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "]]>"+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "]]&gt;"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CSS"+          , Context+              { cName = "CSS"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Django HTML Template" , "CSS content" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindAttributes" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CSS content"+          , Context+              { cName = "CSS content"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</style\\b"+                              , reCompiled = Just (compileRegex False "</style\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Django HTML Template" , "El Close 2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = True+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindTemplate" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "-->"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-(-(?!->))+"+                              , reCompiled = Just (compileRegex True "-(-(?!->))+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype"+          , Context+              { cName = "Doctype"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Django HTML Template" , "Doctype Internal Subset" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Internal Subset"+          , Context+              { cName = "Doctype Internal Subset"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindDTDRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Django HTML Template" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\?[\\w:-]*"+                              , reCompiled = Just (compileRegex True "<\\?[\\w:-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Django HTML Template" , "PI" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindPEntityRefs" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Markupdecl"+          , Context+              { cName = "Doctype Markupdecl"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Django HTML Template" , "Doctype Markupdecl DQ" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Django HTML Template" , "Doctype Markupdecl SQ" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Markupdecl DQ"+          , Context+              { cName = "Doctype Markupdecl DQ"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindPEntityRefs" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Markupdecl SQ"+          , Context+              { cName = "Doctype Markupdecl SQ"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindPEntityRefs" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "El Close"+          , Context+              { cName = "El Close"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "El Close 2"+          , Context+              { cName = "El Close 2"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "El Close 3"+          , Context+              { cName = "El Close 3"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "El Open"+          , Context+              { cName = "El Open"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindAttributes" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindAttributes"+          , Context+              { cName = "FindAttributes"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Za-z_:][\\w.:_-]*"+                              , reCompiled = Just (compileRegex True "[A-Za-z_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+[A-Za-z_:][\\w.:_-]*"+                              , reCompiled = Just (compileRegex True "\\s+[A-Za-z_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Django HTML Template" , "Value" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindDTDRules"+          , Context+              { cName = "FindDTDRules"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<!(ELEMENT|ENTITY|ATTLIST|NOTATION)\\b"+                              , reCompiled =+                                  Just (compileRegex True "<!(ELEMENT|ENTITY|ATTLIST|NOTATION)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Django HTML Template" , "Doctype Markupdecl" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindEntityRefs"+          , Context+              { cName = "FindEntityRefs"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "&<"+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindHTML"+          , Context+              { cName = "FindHTML"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Django HTML Template" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<![CDATA["+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Django HTML Template" , "CDATA" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<!DOCTYPE\\s+"+                              , reCompiled = Just (compileRegex True "<!DOCTYPE\\s+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Django HTML Template" , "Doctype" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\?[\\w:-]*"+                              , reCompiled = Just (compileRegex True "<\\?[\\w:-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Django HTML Template" , "PI" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<style\\b"+                              , reCompiled = Just (compileRegex False "<style\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Django HTML Template" , "CSS" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<script\\b"+                              , reCompiled = Just (compileRegex False "<script\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Django HTML Template" , "JS" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<pre\\b"+                              , reCompiled = Just (compileRegex False "<pre\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Django HTML Template" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<div\\b"+                              , reCompiled = Just (compileRegex False "<div\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Django HTML Template" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<table\\b"+                              , reCompiled = Just (compileRegex False "<table\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Django HTML Template" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<[A-Za-z_:][\\w.:_-]*"+                              , reCompiled = Just (compileRegex True "<[A-Za-z_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Django HTML Template" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</pre\\b"+                              , reCompiled = Just (compileRegex False "</pre\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Django HTML Template" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</div\\b"+                              , reCompiled = Just (compileRegex False "</div\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Django HTML Template" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</table\\b"+                              , reCompiled = Just (compileRegex False "</table\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Django HTML Template" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</[A-Za-z_:][\\w.:_-]*"+                              , reCompiled = Just (compileRegex True "</[A-Za-z_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Django HTML Template" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindDTDRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindEntityRefs" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindPEntityRefs"+          , Context+              { cName = "FindPEntityRefs"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%[A-Za-z_:][\\w.:_-]*;"+                              , reCompiled = Just (compileRegex True "%[A-Za-z_:][\\w.:_-]*;")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "&%"+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindTemplate"+          , Context+              { cName = "FindTemplate"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{%\\s*comment\\s*%\\}"+                              , reCompiled = Just (compileRegex True "\\{%\\s*comment\\s*%\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Django HTML Template" , "Template Comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '{' '{'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Django HTML Template" , "Template Var" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '{' '%'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Django HTML Template" , "Template Tag" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Found Block Tag"+          , Context+              { cName = "Found Block Tag"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([A-Za-z_:][\\w.:_-]*)"+                              , reCompiled = Just (compileRegex True "([A-Za-z_:][\\w.:_-]*)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Django HTML Template" , "In Block Tag" ) ]+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "In Block"+          , Context+              { cName = "In Block"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{%\\s*end[a-z]+\\s*%\\}"+                              , reCompiled = Just (compileRegex True "\\{%\\s*end[a-z]+\\s*%\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Django HTML Template" , "FindHTML" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "In Block Tag"+          , Context+              { cName = "In Block Tag"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{%\\s*end%1\\s*%\\}"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{%\\s*end[a-z]+\\s*%\\}"+                              , reCompiled = Just (compileRegex True "\\{%\\s*end[a-z]+\\s*%\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Django HTML Template" , "Non Matching Tag" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '%' '}'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Django HTML Template" , "In Block" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "In Template Tag" )+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "In Template Tag"+          , Context+              { cName = "In Template Tag"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '%' '}'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Django HTML Template" , "Single A-string" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Django HTML Template" , "Single Q-string" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '{' '{'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '{' '%'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '}' '}'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "JS"+          , Context+              { cName = "JS"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Django HTML Template" , "JS content" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindAttributes" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "JS comment close"+          , Context+              { cName = "JS comment close"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</script\\b"+                              , reCompiled = Just (compileRegex False "</script\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Django HTML Template" , "El Close 3" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindTemplate" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "JS content"+          , Context+              { cName = "JS content"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</script\\b"+                              , reCompiled = Just (compileRegex False "</script\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Django HTML Template" , "El Close 2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "//(?=.*</script\\b)"+                              , reCompiled = Just (compileRegex False "//(?=.*</script\\b)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Django HTML Template" , "JS comment close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "JavaScript" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = True+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Non Matching Tag"+          , Context+              { cName = "Non Matching Tag"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "endautoescape"+                               , "endblock"+                               , "endblocktrans"+                               , "endfor"+                               , "endif"+                               , "endifchanged"+                               , "endifequal"+                               , "endifnotequal"+                               , "endspaceless"+                               ])+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "PI"+          , Context+              { cName = "PI"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '?' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Single A-string"+          , Context+              { cName = "Single A-string"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Single Q-string"+          , Context+              { cName = "Single Q-string"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Start"+          , Context+              { cName = "Start"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{%\\s*end[a-z]+\\s*%\\}"+                              , reCompiled = Just (compileRegex True "\\{%\\s*end[a-z]+\\s*%\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Django HTML Template" , "FindHTML" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Template Comment"+          , Context+              { cName = "Template Comment"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{%\\s*endcomment\\s*%\\}"+                              , reCompiled =+                                  Just (compileRegex True "\\{%\\s*endcomment\\s*%\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Template Filter"+          , Context+              { cName = "Template Filter"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '}' '}'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Django HTML Template" , "Single A-string" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Django HTML Template" , "Single Q-string" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '{' '{'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '{' '%'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '%' '}'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Template Tag"+          , Context+              { cName = "Template Tag"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "autoescape"+                               , "block"+                               , "blocktrans"+                               , "for"+                               , "if"+                               , "ifchanged"+                               , "ifequal"+                               , "ifnotequal"+                               , "spaceless"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Django HTML Template" , "Found Block Tag" ) ]+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Django HTML Template" , "In Template Tag" ) ]+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Template Var"+          , Context+              { cName = "Template Var"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '}' '}'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '|'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Django HTML Template" , "Template Filter" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '{' '{'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '{' '%'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '%' '}'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Value"+          , Context+              { cName = "Value"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Django HTML Template" , "Value DQ" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Django HTML Template" , "Value SQ" ) ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext =+                  [ Push ( "Django HTML Template" , "Value NQ" ) ]+              , cDynamic = False+              }+          )+        , ( "Value DQ"+          , Context+              { cName = "Value DQ"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindTemplate" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindEntityRefs" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Value NQ"+          , Context+              { cName = "Value NQ"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindEntityRefs" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/(?!>)"+                              , reCompiled = Just (compileRegex True "/(?!>)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^/><\"'\\s]"+                              , reCompiled = Just (compileRegex True "[^/><\"'\\s]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop , Pop ]+              , cDynamic = False+              }+          )+        , ( "Value SQ"+          , Context+              { cName = "Value SQ"+              , cSyntax = "Django HTML Template"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindTemplate" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Django HTML Template" , "FindEntityRefs" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Matthew Marshall (matthew@matthewmarshall.org)"+  , sVersion = "3"+  , sLicense = "LGPL"+  , sExtensions = [ "*.htm" , "*.html" ]+  , sStartingContext = "Start"+  }
+ src/Skylighting/Syntax/Dockerfile.hs view
@@ -0,0 +1,252 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Dockerfile (syntax) where++import Skylighting.Types+import Data.Map+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Dockerfile"+  , sFilename = "dockerfile.xml"+  , sShortname = "Dockerfile"+  , sContexts =+      fromList+        [ ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "Dockerfile"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "normal"+          , Context+              { cName = "normal"+              , cSyntax = "Dockerfile"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Dockerfile" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ADD"+                               , "ARG"+                               , "CMD"+                               , "COPY"+                               , "ENTRYPOINT"+                               , "ENV"+                               , "EXPOSE"+                               , "FROM"+                               , "HEALTHCHECK"+                               , "LABEL"+                               , "MAINTAINER"+                               , "ONBUILD"+                               , "RUN"+                               , "SHELL"+                               , "STOPSIGNAL"+                               , "USER"+                               , "VOLUME"+                               , "WORKDIR"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Dockerfile" , "string\"" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Dockerfile" , "string'" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "string\""+          , Context+              { cName = "string\""+              , cSyntax = "Dockerfile"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "string'"+          , Context+              { cName = "string'"+              , cSyntax = "Dockerfile"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "James Turnbull (james@lovedthanlost.net)"+  , sVersion = "5"+  , sLicense = "LGPLv2+"+  , sExtensions = [ "Dockerfile" ]+  , sStartingContext = "normal"+  }
+ src/Skylighting/Syntax/Dot.hs view
@@ -0,0 +1,571 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Dot (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "dot"+  , sFilename = "dot.xml"+  , sShortname = "Dot"+  , sContexts =+      fromList+        [ ( "CommentML"+          , Context+              { cName = "CommentML"+              , cSyntax = "dot"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CommentSL"+          , Context+              { cName = "CommentSL"+              , cSyntax = "dot"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DetectAll"+          , Context+              { cName = "DetectAll"+              , cSyntax = "dot"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "digraph" , "edge" , "node" , "subgraph" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "URL"+                               , "arrowhead"+                               , "arrowsize"+                               , "arrowtail"+                               , "bgcolor"+                               , "center"+                               , "color"+                               , "constraint"+                               , "decorateP"+                               , "dir"+                               , "distortion"+                               , "fillcolor"+                               , "fontcolor"+                               , "fontname"+                               , "fontsize"+                               , "headclip"+                               , "headlabel"+                               , "height"+                               , "label"+                               , "labelangle"+                               , "labeldistance"+                               , "labelfontcolor"+                               , "labelfontname"+                               , "labelfontsize"+                               , "layer"+                               , "layers"+                               , "margin"+                               , "mclimit"+                               , "minlen"+                               , "name"+                               , "nodesep"+                               , "nslimit"+                               , "ordering"+                               , "orientation"+                               , "page"+                               , "pagedir"+                               , "peripheries"+                               , "port_label_distance"+                               , "rank"+                               , "rankdir"+                               , "ranksep"+                               , "ratio"+                               , "regular"+                               , "rotate"+                               , "samehead"+                               , "sametail"+                               , "shape"+                               , "shapefile"+                               , "sides"+                               , "size"+                               , "skew"+                               , "style"+                               , "tailclip"+                               , "taillabel"+                               , "weight"+                               , "width"+                               ])+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "dot" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar ";="+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '-' '>'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b\\w+\\b"+                              , reCompiled = Just (compileRegex True "\\b\\w+\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "dot" , "DetectComments" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "dot" , "RegionCurly" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "dot" , "RegionSquare" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "dot" , "RegionParen" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar ")]}"+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DetectComments"+          , Context+              { cName = "DetectComments"+              , cSyntax = "dot"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "dot" , "CommentSL" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "dot" , "CommentML" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "dot"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "dot" , "DetectAll" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RegionCurly"+          , Context+              { cName = "RegionCurly"+              , cSyntax = "dot"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "dot" , "DetectAll" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RegionParen"+          , Context+              { cName = "RegionParen"+              , cSyntax = "dot"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "dot" , "DetectAll" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RegionSquare"+          , Context+              { cName = "RegionSquare"+              , cSyntax = "dot"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "dot" , "DetectAll" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "dot"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '"'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Postula Lo\239s (lois.postula@live.be)"+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.dot" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Doxygen.hs view
@@ -0,0 +1,3228 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Doxygen (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Doxygen"+  , sFilename = "doxygen.xml"+  , sShortname = "Doxygen"+  , sContexts =+      fromList+        [ ( "BlockComment"+          , Context+              { cName = "BlockComment"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '@' '{'+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '@' '}'+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "SL_DetectEnv" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet+                               True+                               [ "@\""+                               , "@#"+                               , "@$"+                               , "@%"+                               , "@&"+                               , "@--"+                               , "@---"+                               , "@."+                               , "@::"+                               , "@<"+                               , "@>"+                               , "@@"+                               , "@\\"+                               , "@arg"+                               , "@author"+                               , "@authors"+                               , "@brief"+                               , "@callergraph"+                               , "@callgraph"+                               , "@date"+                               , "@deprecated"+                               , "@details"+                               , "@docbookonly"+                               , "@else"+                               , "@endcond"+                               , "@enddocbookonly"+                               , "@endhtmlonly"+                               , "@endif"+                               , "@endinternal"+                               , "@endlatexonly"+                               , "@endlink"+                               , "@endmanonly"+                               , "@endparblock"+                               , "@endrtfonly"+                               , "@endsecreflist"+                               , "@endxmlonly"+                               , "@f$"+                               , "@f["+                               , "@f]"+                               , "@hideinitializer"+                               , "@htmlonly"+                               , "@internal"+                               , "@invariant"+                               , "@latexonly"+                               , "@li"+                               , "@manonly"+                               , "@n"+                               , "@nosubgrouping"+                               , "@only"+                               , "@parblock"+                               , "@pivate"+                               , "@pivatesection"+                               , "@post"+                               , "@pre"+                               , "@protected"+                               , "@protectedsection"+                               , "@public"+                               , "@publicsection"+                               , "@pure"+                               , "@remark"+                               , "@remarks"+                               , "@result"+                               , "@return"+                               , "@returns"+                               , "@rtfonly"+                               , "@sa"+                               , "@secreflist"+                               , "@see"+                               , "@short"+                               , "@showinitializer"+                               , "@since"+                               , "@static"+                               , "@tableofcontents"+                               , "@test"+                               , "@version"+                               , "@xmlonly"+                               , "@~"+                               , "\\\""+                               , "\\#"+                               , "\\$"+                               , "\\%"+                               , "\\&"+                               , "\\--"+                               , "\\---"+                               , "\\."+                               , "\\::"+                               , "\\<"+                               , "\\>"+                               , "\\@"+                               , "\\\\"+                               , "\\arg"+                               , "\\author"+                               , "\\authors"+                               , "\\brief"+                               , "\\callergraph"+                               , "\\callgraph"+                               , "\\date"+                               , "\\deprecated"+                               , "\\details"+                               , "\\docbookonly"+                               , "\\else"+                               , "\\endcond"+                               , "\\enddocbookonly"+                               , "\\endhtmlonly"+                               , "\\endif"+                               , "\\endinternal"+                               , "\\endlatexonly"+                               , "\\endlink"+                               , "\\endmanonly"+                               , "\\endparblock"+                               , "\\endrtfonly"+                               , "\\endsecreflist"+                               , "\\endxmlonly"+                               , "\\f$"+                               , "\\f["+                               , "\\f]"+                               , "\\hideinitializer"+                               , "\\htmlonly"+                               , "\\internal"+                               , "\\invariant"+                               , "\\latexonly"+                               , "\\li"+                               , "\\manonly"+                               , "\\n"+                               , "\\nosubgrouping"+                               , "\\only"+                               , "\\parblock"+                               , "\\post"+                               , "\\pre"+                               , "\\private"+                               , "\\privatesection"+                               , "\\protected"+                               , "\\protectedsection"+                               , "\\public"+                               , "\\publicsection"+                               , "\\pure"+                               , "\\remark"+                               , "\\remarks"+                               , "\\result"+                               , "\\return"+                               , "\\returns"+                               , "\\rtfonly"+                               , "\\sa"+                               , "\\secreflist"+                               , "\\see"+                               , "\\short"+                               , "\\showinitializer"+                               , "\\since"+                               , "\\static"+                               , "\\tableofcontents"+                               , "\\test"+                               , "\\version"+                               , "\\xmlonly"+                               , "\\~"+                               ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet+                               True+                               [ "@a"+                               , "@anchor"+                               , "@b"+                               , "@c"+                               , "@cite"+                               , "@cond"+                               , "@copybrief"+                               , "@copydetails"+                               , "@copydoc"+                               , "@def"+                               , "@dir"+                               , "@dontinclude"+                               , "@e"+                               , "@elseif"+                               , "@em"+                               , "@enum"+                               , "@example"+                               , "@exception"+                               , "@exceptions"+                               , "@extends"+                               , "@file"+                               , "@htmlinclude"+                               , "@idlexcept"+                               , "@if"+                               , "@ifnot"+                               , "@implements"+                               , "@include"+                               , "@includelineno"+                               , "@latexinclude"+                               , "@link"+                               , "@memberof"+                               , "@namespace"+                               , "@p"+                               , "@package"+                               , "@property"+                               , "@related"+                               , "@relatedalso"+                               , "@relates"+                               , "@relatesalso"+                               , "@retval"+                               , "@throw"+                               , "@throws"+                               , "@verbinclude"+                               , "@version"+                               , "@xrefitem"+                               , "\\a"+                               , "\\anchor"+                               , "\\b"+                               , "\\c"+                               , "\\cite"+                               , "\\cond"+                               , "\\copybrief"+                               , "\\copydetails"+                               , "\\copydoc"+                               , "\\def"+                               , "\\dir"+                               , "\\dontinclude"+                               , "\\e"+                               , "\\elseif"+                               , "\\em"+                               , "\\enum"+                               , "\\example"+                               , "\\exception"+                               , "\\exceptions"+                               , "\\extends"+                               , "\\file"+                               , "\\htmlinclude"+                               , "\\idlexcept"+                               , "\\if"+                               , "\\ifnot"+                               , "\\implements"+                               , "\\include"+                               , "\\includelineno"+                               , "\\latexinclude"+                               , "\\link"+                               , "\\memberof"+                               , "\\namespace"+                               , "\\p"+                               , "\\package"+                               , "\\property"+                               , "\\related"+                               , "\\relatedalso"+                               , "\\relates"+                               , "\\relatesalso"+                               , "\\retval"+                               , "\\throw"+                               , "\\throws"+                               , "\\verbinclude"+                               , "\\version"+                               , "\\xrefitem"+                               ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "ML_TagWord" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet+                               True [ "@param" , "@tparam" , "\\param" , "\\tparam" ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "ML_TagParam" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet True [ "@image" , "\\image" ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "ML_TagWordWord" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet+                               True+                               [ "@addindex"+                               , "@copyright"+                               , "@fn"+                               , "@ingroup"+                               , "@line"+                               , "@mainpage"+                               , "@name"+                               , "@overload"+                               , "@par"+                               , "@skip"+                               , "@skipline"+                               , "@typedef"+                               , "@until"+                               , "@var"+                               , "@vhdlflow"+                               , "\\addindex"+                               , "\\copyright"+                               , "\\fn"+                               , "\\ingroup"+                               , "\\line"+                               , "\\mainpage"+                               , "\\name"+                               , "\\overload"+                               , "\\par"+                               , "\\skip"+                               , "\\skipline"+                               , "\\typedef"+                               , "\\until"+                               , "\\var"+                               , "\\vhdlflow"+                               ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "ML_TagString" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet+                               True+                               [ "@addtogroup"+                               , "@category"+                               , "@class"+                               , "@defgroup"+                               , "@diafile"+                               , "@dotfile"+                               , "@headerfile"+                               , "@interface"+                               , "@mscfile"+                               , "@page"+                               , "@paragraph"+                               , "@prtocol"+                               , "@ref"+                               , "@section"+                               , "@snippet"+                               , "@struct"+                               , "@subpage"+                               , "@subsection"+                               , "@subsubsection"+                               , "@union"+                               , "@weakgroup"+                               , "\\addtogroup"+                               , "\\category"+                               , "\\class"+                               , "\\defgroup"+                               , "\\diafile"+                               , "\\dotfile"+                               , "\\headerfile"+                               , "\\interface"+                               , "\\mscfile"+                               , "\\page"+                               , "\\paragraph"+                               , "\\protocol"+                               , "\\ref"+                               , "\\section"+                               , "\\snippet"+                               , "\\struct"+                               , "\\subpage"+                               , "\\subsection"+                               , "\\subsubsection"+                               , "\\union"+                               , "\\weakgroup"+                               ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "ML_TagWordString" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[@\\\\]([^@\\\\ \\t\\*]|\\*(?!/))+"+                              , reCompiled =+                                  Just (compileRegex True "[@\\\\]([^@\\\\ \\t\\*]|\\*(?!/))+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(<|>)"+                              , reCompiled = Just (compileRegex True "\\\\(<|>)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '<' '<'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\/?[\\w0-9._:-@]+"+                              , reCompiled = Just (compileRegex True "<\\/?[\\w0-9._:-@]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "ML_htmltag" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "ML_htmlcomment" ) ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Code"+          , Context+              { cName = "Code"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "SL_DetectComment" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[@\\\\]endcode\\b"+                              , reCompiled = Just (compileRegex True "[@\\\\]endcode\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Dot"+          , Context+              { cName = "Dot"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "SL_DetectComment" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[@\\\\]enddot\\b"+                              , reCompiled = Just (compileRegex True "[@\\\\]enddot\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Formula"+          , Context+              { cName = "Formula"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "SL_DetectComment" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[@\\\\]f\\]"+                              , reCompiled = Just (compileRegex True "[@\\\\]f\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "LineComment"+          , Context+              { cName = "LineComment"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "SL_DetectEnv" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet+                               True+                               [ "@\""+                               , "@#"+                               , "@$"+                               , "@%"+                               , "@&"+                               , "@--"+                               , "@---"+                               , "@."+                               , "@::"+                               , "@<"+                               , "@>"+                               , "@@"+                               , "@\\"+                               , "@arg"+                               , "@author"+                               , "@authors"+                               , "@brief"+                               , "@callergraph"+                               , "@callgraph"+                               , "@date"+                               , "@deprecated"+                               , "@details"+                               , "@docbookonly"+                               , "@else"+                               , "@endcond"+                               , "@enddocbookonly"+                               , "@endhtmlonly"+                               , "@endif"+                               , "@endinternal"+                               , "@endlatexonly"+                               , "@endlink"+                               , "@endmanonly"+                               , "@endparblock"+                               , "@endrtfonly"+                               , "@endsecreflist"+                               , "@endxmlonly"+                               , "@f$"+                               , "@f["+                               , "@f]"+                               , "@hideinitializer"+                               , "@htmlonly"+                               , "@internal"+                               , "@invariant"+                               , "@latexonly"+                               , "@li"+                               , "@manonly"+                               , "@n"+                               , "@nosubgrouping"+                               , "@only"+                               , "@parblock"+                               , "@pivate"+                               , "@pivatesection"+                               , "@post"+                               , "@pre"+                               , "@protected"+                               , "@protectedsection"+                               , "@public"+                               , "@publicsection"+                               , "@pure"+                               , "@remark"+                               , "@remarks"+                               , "@result"+                               , "@return"+                               , "@returns"+                               , "@rtfonly"+                               , "@sa"+                               , "@secreflist"+                               , "@see"+                               , "@short"+                               , "@showinitializer"+                               , "@since"+                               , "@static"+                               , "@tableofcontents"+                               , "@test"+                               , "@version"+                               , "@xmlonly"+                               , "@~"+                               , "\\\""+                               , "\\#"+                               , "\\$"+                               , "\\%"+                               , "\\&"+                               , "\\--"+                               , "\\---"+                               , "\\."+                               , "\\::"+                               , "\\<"+                               , "\\>"+                               , "\\@"+                               , "\\\\"+                               , "\\arg"+                               , "\\author"+                               , "\\authors"+                               , "\\brief"+                               , "\\callergraph"+                               , "\\callgraph"+                               , "\\date"+                               , "\\deprecated"+                               , "\\details"+                               , "\\docbookonly"+                               , "\\else"+                               , "\\endcond"+                               , "\\enddocbookonly"+                               , "\\endhtmlonly"+                               , "\\endif"+                               , "\\endinternal"+                               , "\\endlatexonly"+                               , "\\endlink"+                               , "\\endmanonly"+                               , "\\endparblock"+                               , "\\endrtfonly"+                               , "\\endsecreflist"+                               , "\\endxmlonly"+                               , "\\f$"+                               , "\\f["+                               , "\\f]"+                               , "\\hideinitializer"+                               , "\\htmlonly"+                               , "\\internal"+                               , "\\invariant"+                               , "\\latexonly"+                               , "\\li"+                               , "\\manonly"+                               , "\\n"+                               , "\\nosubgrouping"+                               , "\\only"+                               , "\\parblock"+                               , "\\post"+                               , "\\pre"+                               , "\\private"+                               , "\\privatesection"+                               , "\\protected"+                               , "\\protectedsection"+                               , "\\public"+                               , "\\publicsection"+                               , "\\pure"+                               , "\\remark"+                               , "\\remarks"+                               , "\\result"+                               , "\\return"+                               , "\\returns"+                               , "\\rtfonly"+                               , "\\sa"+                               , "\\secreflist"+                               , "\\see"+                               , "\\short"+                               , "\\showinitializer"+                               , "\\since"+                               , "\\static"+                               , "\\tableofcontents"+                               , "\\test"+                               , "\\version"+                               , "\\xmlonly"+                               , "\\~"+                               ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet+                               True+                               [ "@a"+                               , "@anchor"+                               , "@b"+                               , "@c"+                               , "@cite"+                               , "@cond"+                               , "@copybrief"+                               , "@copydetails"+                               , "@copydoc"+                               , "@def"+                               , "@dir"+                               , "@dontinclude"+                               , "@e"+                               , "@elseif"+                               , "@em"+                               , "@enum"+                               , "@example"+                               , "@exception"+                               , "@exceptions"+                               , "@extends"+                               , "@file"+                               , "@htmlinclude"+                               , "@idlexcept"+                               , "@if"+                               , "@ifnot"+                               , "@implements"+                               , "@include"+                               , "@includelineno"+                               , "@latexinclude"+                               , "@link"+                               , "@memberof"+                               , "@namespace"+                               , "@p"+                               , "@package"+                               , "@property"+                               , "@related"+                               , "@relatedalso"+                               , "@relates"+                               , "@relatesalso"+                               , "@retval"+                               , "@throw"+                               , "@throws"+                               , "@verbinclude"+                               , "@version"+                               , "@xrefitem"+                               , "\\a"+                               , "\\anchor"+                               , "\\b"+                               , "\\c"+                               , "\\cite"+                               , "\\cond"+                               , "\\copybrief"+                               , "\\copydetails"+                               , "\\copydoc"+                               , "\\def"+                               , "\\dir"+                               , "\\dontinclude"+                               , "\\e"+                               , "\\elseif"+                               , "\\em"+                               , "\\enum"+                               , "\\example"+                               , "\\exception"+                               , "\\exceptions"+                               , "\\extends"+                               , "\\file"+                               , "\\htmlinclude"+                               , "\\idlexcept"+                               , "\\if"+                               , "\\ifnot"+                               , "\\implements"+                               , "\\include"+                               , "\\includelineno"+                               , "\\latexinclude"+                               , "\\link"+                               , "\\memberof"+                               , "\\namespace"+                               , "\\p"+                               , "\\package"+                               , "\\property"+                               , "\\related"+                               , "\\relatedalso"+                               , "\\relates"+                               , "\\relatesalso"+                               , "\\retval"+                               , "\\throw"+                               , "\\throws"+                               , "\\verbinclude"+                               , "\\version"+                               , "\\xrefitem"+                               ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "SL_TagWord" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet+                               True [ "@param" , "@tparam" , "\\param" , "\\tparam" ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "SL_TagParam" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet True [ "@image" , "\\image" ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "SL_TagWordWord" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet+                               True+                               [ "@addindex"+                               , "@copyright"+                               , "@fn"+                               , "@ingroup"+                               , "@line"+                               , "@mainpage"+                               , "@name"+                               , "@overload"+                               , "@par"+                               , "@skip"+                               , "@skipline"+                               , "@typedef"+                               , "@until"+                               , "@var"+                               , "@vhdlflow"+                               , "\\addindex"+                               , "\\copyright"+                               , "\\fn"+                               , "\\ingroup"+                               , "\\line"+                               , "\\mainpage"+                               , "\\name"+                               , "\\overload"+                               , "\\par"+                               , "\\skip"+                               , "\\skipline"+                               , "\\typedef"+                               , "\\until"+                               , "\\var"+                               , "\\vhdlflow"+                               ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "SL_TagString" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet+                               True+                               [ "@addtogroup"+                               , "@category"+                               , "@class"+                               , "@defgroup"+                               , "@diafile"+                               , "@dotfile"+                               , "@headerfile"+                               , "@interface"+                               , "@mscfile"+                               , "@page"+                               , "@paragraph"+                               , "@prtocol"+                               , "@ref"+                               , "@section"+                               , "@snippet"+                               , "@struct"+                               , "@subpage"+                               , "@subsection"+                               , "@subsubsection"+                               , "@union"+                               , "@weakgroup"+                               , "\\addtogroup"+                               , "\\category"+                               , "\\class"+                               , "\\defgroup"+                               , "\\diafile"+                               , "\\dotfile"+                               , "\\headerfile"+                               , "\\interface"+                               , "\\mscfile"+                               , "\\page"+                               , "\\paragraph"+                               , "\\protocol"+                               , "\\ref"+                               , "\\section"+                               , "\\snippet"+                               , "\\struct"+                               , "\\subpage"+                               , "\\subsection"+                               , "\\subsubsection"+                               , "\\union"+                               , "\\weakgroup"+                               ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "SL_TagWordString" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[@\\\\][^@\\\\ \\t]+"+                              , reCompiled = Just (compileRegex True "[@\\\\][^@\\\\ \\t]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "SL_htmlcomment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '<' '<'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\/?[\\w0-9._:-@]+"+                              , reCompiled = Just (compileRegex True "<\\/?[\\w0-9._:-@]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "SL_htmltag" ) ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ML_Tag2ndWord"+          , Context+              { cName = "ML_Tag2ndWord"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "SL_Tag2ndWord" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ML_TagParam"+          , Context+              { cName = "ML_TagParam"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "[in]"+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "ML_Tag2ndWord" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "[out]"+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "ML_Tag2ndWord" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "[in,out]"+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "ML_Tag2ndWord" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S(?=([][,?;()]|\\.$|\\.?\\s))"+                              , reCompiled =+                                  Just (compileRegex True "\\S(?=([][,?;()]|\\.$|\\.?\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ML_TagString"+          , Context+              { cName = "ML_TagString"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "ML_htmlcomment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '<' '<'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\/?[\\w0-9._:-@]+"+                              , reCompiled = Just (compileRegex True "<\\/?[\\w0-9._:-@]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "ML_htmltag" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ML_TagWord"+          , Context+              { cName = "ML_TagWord"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "SL_TagWord" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ML_TagWordString"+          , Context+              { cName = "ML_TagWordString"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "SL_TagWordString" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ML_TagWordWord"+          , Context+              { cName = "ML_TagWordWord"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S(?=([][,?;()]|\\.$|\\.?\\s))"+                              , reCompiled =+                                  Just (compileRegex True "\\S(?=([][,?;()]|\\.$|\\.?\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "ML_Tag2ndWord" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ML_htmlcomment"+          , Context+              { cName = "ML_htmlcomment"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "-->"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ML_htmltag"+          , Context+              { cName = "ML_htmltag"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*=\\s*"+                              , reCompiled = Just (compileRegex True "\\s*=\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "ML_identifiers" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ML_identifiers"+          , Context+              { cName = "ML_identifiers"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*#?[a-zA-Z0-9]*"+                              , reCompiled = Just (compileRegex True "\\s*#?[a-zA-Z0-9]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "ML_types1" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "ML_types2" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ML_types1"+          , Context+              { cName = "ML_types1"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ML_types2"+          , Context+              { cName = "ML_types2"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Msc"+          , Context+              { cName = "Msc"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "SL_DetectComment" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[@\\\\]endmsc\\b"+                              , reCompiled = Just (compileRegex True "[@\\\\]endmsc\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "//(!|(/(?=[^/]|$)))<?"+                              , reCompiled = Just (compileRegex True "//(!|(/(?=[^/]|$)))<?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "LineComment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/\\*(\\*[^*/]|!|[*!]<|\\*$)"+                              , reCompiled =+                                  Just (compileRegex True "/\\*(\\*[^*/]|!|[*!]<|\\*$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "BlockComment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "//\\s*@\\{\\s*$"+                              , reCompiled = Just (compileRegex True "//\\s*@\\{\\s*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "//\\s*@\\}\\s*$"+                              , reCompiled = Just (compileRegex True "//\\s*@\\}\\s*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/\\*\\s*@\\{\\s*\\*/"+                              , reCompiled = Just (compileRegex True "/\\*\\s*@\\{\\s*\\*/")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/\\*\\s*@\\}\\s*\\*/"+                              , reCompiled = Just (compileRegex True "/\\*\\s*@\\}\\s*\\*/")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_DetectComment"+          , Context+              { cName = "SL_DetectComment"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "///"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_DetectEnv"+          , Context+              { cName = "SL_DetectEnv"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[@\\\\]code\\b"+                              , reCompiled = Just (compileRegex True "[@\\\\]code\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "Code" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[@\\\\]verbatim\\b"+                              , reCompiled = Just (compileRegex True "[@\\\\]verbatim\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "Verbatim" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[@\\\\]f\\["+                              , reCompiled = Just (compileRegex True "[@\\\\]f\\[")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "Formula" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[@\\\\]msc\\b"+                              , reCompiled = Just (compileRegex True "[@\\\\]msc\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "Msc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[@\\\\]dot\\b"+                              , reCompiled = Just (compileRegex True "[@\\\\]dot\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "Dot" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet True [ "@note" , "\\note" ])+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet True [ "@warning" , "\\warning" ])+                      , rAttribute = WarningTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet+                               True [ "@attention" , "@bug" , "\\attention" , "\\bug" ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet True [ "@todo" , "\\todo" ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&[A-Za-z]+;"+                              , reCompiled = Just (compileRegex True "&[A-Za-z]+;")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_Tag2ndWord"+          , Context+              { cName = "SL_Tag2ndWord"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S(?=([][,?;()]|\\.$|\\.?\\s))"+                              , reCompiled =+                                  Just (compileRegex True "\\S(?=([][,?;()]|\\.$|\\.?\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_TagParam"+          , Context+              { cName = "SL_TagParam"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "[in]"+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "SL_Tag2ndWord" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "[out]"+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "SL_Tag2ndWord" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "[in,out]"+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "SL_Tag2ndWord" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S(?=([][,?;()]|\\.$|\\.?\\s))"+                              , reCompiled =+                                  Just (compileRegex True "\\S(?=([][,?;()]|\\.$|\\.?\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_TagString"+          , Context+              { cName = "SL_TagString"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "SL_htmlcomment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '<' '<'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\/?[\\w0-9._:-@]+"+                              , reCompiled = Just (compileRegex True "<\\/?[\\w0-9._:-@]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "SL_htmltag" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_TagWord"+          , Context+              { cName = "SL_TagWord"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet+                               True+                               [ "@a"+                               , "@anchor"+                               , "@b"+                               , "@c"+                               , "@cite"+                               , "@cond"+                               , "@copybrief"+                               , "@copydetails"+                               , "@copydoc"+                               , "@def"+                               , "@dir"+                               , "@dontinclude"+                               , "@e"+                               , "@elseif"+                               , "@em"+                               , "@enum"+                               , "@example"+                               , "@exception"+                               , "@exceptions"+                               , "@extends"+                               , "@file"+                               , "@htmlinclude"+                               , "@idlexcept"+                               , "@if"+                               , "@ifnot"+                               , "@implements"+                               , "@include"+                               , "@includelineno"+                               , "@latexinclude"+                               , "@link"+                               , "@memberof"+                               , "@namespace"+                               , "@p"+                               , "@package"+                               , "@property"+                               , "@related"+                               , "@relatedalso"+                               , "@relates"+                               , "@relatesalso"+                               , "@retval"+                               , "@throw"+                               , "@throws"+                               , "@verbinclude"+                               , "@version"+                               , "@xrefitem"+                               , "\\a"+                               , "\\anchor"+                               , "\\b"+                               , "\\c"+                               , "\\cite"+                               , "\\cond"+                               , "\\copybrief"+                               , "\\copydetails"+                               , "\\copydoc"+                               , "\\def"+                               , "\\dir"+                               , "\\dontinclude"+                               , "\\e"+                               , "\\elseif"+                               , "\\em"+                               , "\\enum"+                               , "\\example"+                               , "\\exception"+                               , "\\exceptions"+                               , "\\extends"+                               , "\\file"+                               , "\\htmlinclude"+                               , "\\idlexcept"+                               , "\\if"+                               , "\\ifnot"+                               , "\\implements"+                               , "\\include"+                               , "\\includelineno"+                               , "\\latexinclude"+                               , "\\link"+                               , "\\memberof"+                               , "\\namespace"+                               , "\\p"+                               , "\\package"+                               , "\\property"+                               , "\\related"+                               , "\\relatedalso"+                               , "\\relates"+                               , "\\relatesalso"+                               , "\\retval"+                               , "\\throw"+                               , "\\throws"+                               , "\\verbinclude"+                               , "\\version"+                               , "\\xrefitem"+                               ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S(?=([][,?;()]|\\.$|\\.?\\s))"+                              , reCompiled =+                                  Just (compileRegex True "\\S(?=([][,?;()]|\\.$|\\.?\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_TagWordString"+          , Context+              { cName = "SL_TagWordString"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S(?=([][,?;()]|\\.$|\\.?\\s))"+                              , reCompiled =+                                  Just (compileRegex True "\\S(?=([][,?;()]|\\.$|\\.?\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_TagWordWord"+          , Context+              { cName = "SL_TagWordWord"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S(?=([][,?;()]|\\.$|\\.?\\s))"+                              , reCompiled =+                                  Just (compileRegex True "\\S(?=([][,?;()]|\\.$|\\.?\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "SL_Tag2ndWord" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_htmlcomment"+          , Context+              { cName = "SL_htmlcomment"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "-->"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_htmltag"+          , Context+              { cName = "SL_htmltag"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*=\\s*"+                              , reCompiled = Just (compileRegex True "\\s*=\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "SL_identifiers" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_identifiers"+          , Context+              { cName = "SL_identifiers"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*#?[a-zA-Z0-9]*"+                              , reCompiled = Just (compileRegex True "\\s*#?[a-zA-Z0-9]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "SL_types1" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Doxygen" , "SL_types2" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_types1"+          , Context+              { cName = "SL_types1"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_types2"+          , Context+              { cName = "SL_types2"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Verbatim"+          , Context+              { cName = "Verbatim"+              , cSyntax = "Doxygen"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "SL_DetectComment" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[@\\\\]endverbatim\\b"+                              , reCompiled = Just (compileRegex True "[@\\\\]endverbatim\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Dominik Haumann (dhdev@gmx.de)"+  , sVersion = "3"+  , sLicense = "LGPLv2+"+  , sExtensions = [ "*.dox" , "*.doxygen" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Doxygenlua.hs view
@@ -0,0 +1,2418 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Doxygenlua (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "DoxygenLua"+  , sFilename = "doxygenlua.xml"+  , sShortname = "Doxygenlua"+  , sContexts =+      fromList+        [ ( "BlockComment"+          , Context+              { cName = "BlockComment"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\]%1\\]"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '@' '{'+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '@' '}'+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet+                               False+                               [ "@#"+                               , "@$"+                               , "@@"+                               , "@\\"+                               , "@arg"+                               , "@attention"+                               , "@author"+                               , "@callgraph"+                               , "@code"+                               , "@dot"+                               , "@else"+                               , "@endcode"+                               , "@endcond"+                               , "@enddot"+                               , "@endhtmlonly"+                               , "@endif"+                               , "@endlatexonly"+                               , "@endlink"+                               , "@endmanonly"+                               , "@endverbatim"+                               , "@endxmlonly"+                               , "@f$"+                               , "@f["+                               , "@f]"+                               , "@hideinitializer"+                               , "@htmlonly"+                               , "@interface"+                               , "@internal"+                               , "@invariant"+                               , "@latexonly"+                               , "@li"+                               , "@manonly"+                               , "@n"+                               , "@nosubgrouping"+                               , "@note"+                               , "@only"+                               , "@post"+                               , "@pre"+                               , "@remarks"+                               , "@return"+                               , "@returns"+                               , "@sa"+                               , "@see"+                               , "@showinitializer"+                               , "@since"+                               , "@test"+                               , "@todo"+                               , "@verbatim"+                               , "@warning"+                               , "@xmlonly"+                               , "@~"+                               , "\\#"+                               , "\\$"+                               , "\\@"+                               , "\\\\"+                               , "\\arg"+                               , "\\attention"+                               , "\\author"+                               , "\\callgraph"+                               , "\\code"+                               , "\\dot"+                               , "\\else"+                               , "\\endcode"+                               , "\\endcond"+                               , "\\enddot"+                               , "\\endhtmlonly"+                               , "\\endif"+                               , "\\endlatexonly"+                               , "\\endlink"+                               , "\\endmanonly"+                               , "\\endverbatim"+                               , "\\endxmlonly"+                               , "\\f$"+                               , "\\f["+                               , "\\f]"+                               , "\\hideinitializer"+                               , "\\htmlonly"+                               , "\\interface"+                               , "\\internal"+                               , "\\invariant"+                               , "\\latexonly"+                               , "\\li"+                               , "\\manonly"+                               , "\\n"+                               , "\\nosubgrouping"+                               , "\\note"+                               , "\\only"+                               , "\\post"+                               , "\\pre"+                               , "\\remarks"+                               , "\\return"+                               , "\\returns"+                               , "\\sa"+                               , "\\see"+                               , "\\showinitializer"+                               , "\\since"+                               , "\\test"+                               , "\\todo"+                               , "\\verbatim"+                               , "\\warning"+                               , "\\xmlonly"+                               , "\\~"+                               ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet+                               False+                               [ "@a"+                               , "@addtogroup"+                               , "@anchor"+                               , "@b"+                               , "@c"+                               , "@class"+                               , "@cond"+                               , "@copydoc"+                               , "@def"+                               , "@dontinclude"+                               , "@dotfile"+                               , "@e"+                               , "@elseif"+                               , "@em"+                               , "@enum"+                               , "@example"+                               , "@exception"+                               , "@exceptions"+                               , "@file"+                               , "@htmlinclude"+                               , "@if"+                               , "@ifnot"+                               , "@include"+                               , "@link"+                               , "@namespace"+                               , "@p"+                               , "@package"+                               , "@ref"+                               , "@relates"+                               , "@relatesalso"+                               , "@retval"+                               , "@throw"+                               , "@throws"+                               , "@verbinclude"+                               , "@version"+                               , "@xrefitem"+                               , "\\a"+                               , "\\addtogroup"+                               , "\\anchor"+                               , "\\b"+                               , "\\c"+                               , "\\class"+                               , "\\cond"+                               , "\\copydoc"+                               , "\\def"+                               , "\\dontinclude"+                               , "\\dotfile"+                               , "\\e"+                               , "\\elseif"+                               , "\\em"+                               , "\\enum"+                               , "\\example"+                               , "\\exception"+                               , "\\exceptions"+                               , "\\file"+                               , "\\htmlinclude"+                               , "\\if"+                               , "\\ifnot"+                               , "\\include"+                               , "\\link"+                               , "\\namespace"+                               , "\\p"+                               , "\\package"+                               , "\\ref"+                               , "\\relates"+                               , "\\relatesalso"+                               , "\\retval"+                               , "\\throw"+                               , "\\throws"+                               , "\\verbinclude"+                               , "\\version"+                               , "\\xrefitem"+                               ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "ML_TagWord" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet False [ "@param" , "\\param" ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "ML_TagParam" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet False [ "@image" , "\\image" ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "ML_TagWordWord" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet+                               False+                               [ "@addindex"+                               , "@brief"+                               , "@bug"+                               , "@date"+                               , "@deprecated"+                               , "@fn"+                               , "@ingroup"+                               , "@line"+                               , "@mainpage"+                               , "@name"+                               , "@overload"+                               , "@par"+                               , "@short"+                               , "@skip"+                               , "@skipline"+                               , "@typedef"+                               , "@until"+                               , "@var"+                               , "\\addindex"+                               , "\\brief"+                               , "\\bug"+                               , "\\date"+                               , "\\deprecated"+                               , "\\fn"+                               , "\\ingroup"+                               , "\\line"+                               , "\\mainpage"+                               , "\\name"+                               , "\\overload"+                               , "\\par"+                               , "\\short"+                               , "\\skip"+                               , "\\skipline"+                               , "\\typedef"+                               , "\\until"+                               , "\\var"+                               ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "ML_TagString" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet+                               False+                               [ "@defgroup"+                               , "@page"+                               , "@paragraph"+                               , "@section"+                               , "@struct"+                               , "@subsection"+                               , "@subsubsection"+                               , "@union"+                               , "@weakgroup"+                               , "\\defgroup"+                               , "\\page"+                               , "\\paragraph"+                               , "\\section"+                               , "\\struct"+                               , "\\subsection"+                               , "\\subsubsection"+                               , "\\union"+                               , "\\weakgroup"+                               ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "ML_TagWordString" ) ]+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(<|>)"+                              , reCompiled = Just (compileRegex True "\\\\(<|>)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '<' '<'+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\s*\\/?\\s*[a-zA-Z_:][a-zA-Z0-9._:-]*"+                              , reCompiled =+                                  Just (compileRegex True "<\\s*\\/?\\s*[a-zA-Z_:][a-zA-Z0-9._:-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "ML_htmltag" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "ML_htmlcomment" ) ]+                      }+                  ]+              , cAttribute = DocumentationTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "LineComment"+          , Context+              { cName = "LineComment"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet+                               False+                               [ "@#"+                               , "@$"+                               , "@@"+                               , "@\\"+                               , "@arg"+                               , "@attention"+                               , "@author"+                               , "@callgraph"+                               , "@code"+                               , "@dot"+                               , "@else"+                               , "@endcode"+                               , "@endcond"+                               , "@enddot"+                               , "@endhtmlonly"+                               , "@endif"+                               , "@endlatexonly"+                               , "@endlink"+                               , "@endmanonly"+                               , "@endverbatim"+                               , "@endxmlonly"+                               , "@f$"+                               , "@f["+                               , "@f]"+                               , "@hideinitializer"+                               , "@htmlonly"+                               , "@interface"+                               , "@internal"+                               , "@invariant"+                               , "@latexonly"+                               , "@li"+                               , "@manonly"+                               , "@n"+                               , "@nosubgrouping"+                               , "@note"+                               , "@only"+                               , "@post"+                               , "@pre"+                               , "@remarks"+                               , "@return"+                               , "@returns"+                               , "@sa"+                               , "@see"+                               , "@showinitializer"+                               , "@since"+                               , "@test"+                               , "@todo"+                               , "@verbatim"+                               , "@warning"+                               , "@xmlonly"+                               , "@~"+                               , "\\#"+                               , "\\$"+                               , "\\@"+                               , "\\\\"+                               , "\\arg"+                               , "\\attention"+                               , "\\author"+                               , "\\callgraph"+                               , "\\code"+                               , "\\dot"+                               , "\\else"+                               , "\\endcode"+                               , "\\endcond"+                               , "\\enddot"+                               , "\\endhtmlonly"+                               , "\\endif"+                               , "\\endlatexonly"+                               , "\\endlink"+                               , "\\endmanonly"+                               , "\\endverbatim"+                               , "\\endxmlonly"+                               , "\\f$"+                               , "\\f["+                               , "\\f]"+                               , "\\hideinitializer"+                               , "\\htmlonly"+                               , "\\interface"+                               , "\\internal"+                               , "\\invariant"+                               , "\\latexonly"+                               , "\\li"+                               , "\\manonly"+                               , "\\n"+                               , "\\nosubgrouping"+                               , "\\note"+                               , "\\only"+                               , "\\post"+                               , "\\pre"+                               , "\\remarks"+                               , "\\return"+                               , "\\returns"+                               , "\\sa"+                               , "\\see"+                               , "\\showinitializer"+                               , "\\since"+                               , "\\test"+                               , "\\todo"+                               , "\\verbatim"+                               , "\\warning"+                               , "\\xmlonly"+                               , "\\~"+                               ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet+                               False+                               [ "@a"+                               , "@addtogroup"+                               , "@anchor"+                               , "@b"+                               , "@c"+                               , "@class"+                               , "@cond"+                               , "@copydoc"+                               , "@def"+                               , "@dontinclude"+                               , "@dotfile"+                               , "@e"+                               , "@elseif"+                               , "@em"+                               , "@enum"+                               , "@example"+                               , "@exception"+                               , "@exceptions"+                               , "@file"+                               , "@htmlinclude"+                               , "@if"+                               , "@ifnot"+                               , "@include"+                               , "@link"+                               , "@namespace"+                               , "@p"+                               , "@package"+                               , "@ref"+                               , "@relates"+                               , "@relatesalso"+                               , "@retval"+                               , "@throw"+                               , "@throws"+                               , "@verbinclude"+                               , "@version"+                               , "@xrefitem"+                               , "\\a"+                               , "\\addtogroup"+                               , "\\anchor"+                               , "\\b"+                               , "\\c"+                               , "\\class"+                               , "\\cond"+                               , "\\copydoc"+                               , "\\def"+                               , "\\dontinclude"+                               , "\\dotfile"+                               , "\\e"+                               , "\\elseif"+                               , "\\em"+                               , "\\enum"+                               , "\\example"+                               , "\\exception"+                               , "\\exceptions"+                               , "\\file"+                               , "\\htmlinclude"+                               , "\\if"+                               , "\\ifnot"+                               , "\\include"+                               , "\\link"+                               , "\\namespace"+                               , "\\p"+                               , "\\package"+                               , "\\ref"+                               , "\\relates"+                               , "\\relatesalso"+                               , "\\retval"+                               , "\\throw"+                               , "\\throws"+                               , "\\verbinclude"+                               , "\\version"+                               , "\\xrefitem"+                               ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "SL_TagWord" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet False [ "@param" , "\\param" ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "SL_TagParam" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet False [ "@image" , "\\image" ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "SL_TagWordWord" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet+                               False+                               [ "@addindex"+                               , "@brief"+                               , "@bug"+                               , "@date"+                               , "@deprecated"+                               , "@fn"+                               , "@ingroup"+                               , "@line"+                               , "@mainpage"+                               , "@name"+                               , "@overload"+                               , "@par"+                               , "@short"+                               , "@skip"+                               , "@skipline"+                               , "@typedef"+                               , "@until"+                               , "@var"+                               , "\\addindex"+                               , "\\brief"+                               , "\\bug"+                               , "\\date"+                               , "\\deprecated"+                               , "\\fn"+                               , "\\ingroup"+                               , "\\line"+                               , "\\mainpage"+                               , "\\name"+                               , "\\overload"+                               , "\\par"+                               , "\\short"+                               , "\\skip"+                               , "\\skipline"+                               , "\\typedef"+                               , "\\until"+                               , "\\var"+                               ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "SL_TagString" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet+                               False+                               [ "@defgroup"+                               , "@page"+                               , "@paragraph"+                               , "@section"+                               , "@struct"+                               , "@subsection"+                               , "@subsubsection"+                               , "@union"+                               , "@weakgroup"+                               , "\\defgroup"+                               , "\\page"+                               , "\\paragraph"+                               , "\\section"+                               , "\\struct"+                               , "\\subsection"+                               , "\\subsubsection"+                               , "\\union"+                               , "\\weakgroup"+                               ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "SL_TagWordString" ) ]+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "SL_htmlcomment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '<' '<'+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\s*\\/?\\s*[a-zA-Z_:][a-zA-Z0-9._:-]*"+                              , reCompiled =+                                  Just (compileRegex True "<\\s*\\/?\\s*[a-zA-Z_:][a-zA-Z0-9._:-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "SL_htmltag" ) ]+                      }+                  ]+              , cAttribute = DocumentationTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ML_Tag2ndWord"+          , Context+              { cName = "ML_Tag2ndWord"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "DoxygenLua" , "SL_Tag2ndWord" )+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DocumentationTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ML_TagParam"+          , Context+              { cName = "ML_TagParam"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "[in]"+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "ML_Tag2ndWord" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "[out]"+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "ML_Tag2ndWord" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "[in,out]"+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "ML_Tag2ndWord" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S(?=([][,?;()]|\\.$|\\.?\\s))"+                              , reCompiled =+                                  Just (compileRegex True "\\S(?=([][,?;()]|\\.$|\\.?\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DocumentationTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ML_TagString"+          , Context+              { cName = "ML_TagString"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "ML_htmlcomment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '<' '<'+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\s*\\/?\\s*[a-zA-Z_:][a-zA-Z0-9._:-]*"+                              , reCompiled =+                                  Just (compileRegex True "<\\s*\\/?\\s*[a-zA-Z_:][a-zA-Z0-9._:-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "ML_htmltag" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DocumentationTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ML_TagWord"+          , Context+              { cName = "ML_TagWord"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "DoxygenLua" , "SL_TagWord" )+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DocumentationTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ML_TagWordString"+          , Context+              { cName = "ML_TagWordString"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "DoxygenLua" , "SL_TagWordString" )+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DocumentationTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ML_TagWordWord"+          , Context+              { cName = "ML_TagWordWord"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S(?=([][,?;()]|\\.$|\\.?\\s))"+                              , reCompiled =+                                  Just (compileRegex True "\\S(?=([][,?;()]|\\.$|\\.?\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "ML_Tag2ndWord" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DocumentationTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ML_htmlcomment"+          , Context+              { cName = "ML_htmlcomment"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "-->"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ML_htmltag"+          , Context+              { cName = "ML_htmltag"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*=\\s*"+                              , reCompiled = Just (compileRegex True "\\s*=\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "ML_identifiers" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ML_identifiers"+          , Context+              { cName = "ML_identifiers"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*#?[a-zA-Z0-9]*"+                              , reCompiled = Just (compileRegex True "\\s*#?[a-zA-Z0-9]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "ML_types1" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "ML_types2" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ML_types1"+          , Context+              { cName = "ML_types1"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ML_types2"+          , Context+              { cName = "ML_types2"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "--\\[(=*)\\["+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "BlockComment" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "--"+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "LineComment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_Tag2ndWord"+          , Context+              { cName = "SL_Tag2ndWord"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S(?=([][,?;()]|\\.$|\\.?\\s))"+                              , reCompiled =+                                  Just (compileRegex True "\\S(?=([][,?;()]|\\.$|\\.?\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DocumentationTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_TagParam"+          , Context+              { cName = "SL_TagParam"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "[in]"+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "SL_Tag2ndWord" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "[out]"+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "SL_Tag2ndWord" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "[in,out]"+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "SL_Tag2ndWord" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S(?=([][,?;()]|\\.$|\\.?\\s))"+                              , reCompiled =+                                  Just (compileRegex True "\\S(?=([][,?;()]|\\.$|\\.?\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DocumentationTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_TagString"+          , Context+              { cName = "SL_TagString"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "SL_htmlcomment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '<' '<'+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\s*\\/?\\s*[a-zA-Z_:][a-zA-Z0-9._:-]*"+                              , reCompiled =+                                  Just (compileRegex True "<\\s*\\/?\\s*[a-zA-Z_:][a-zA-Z0-9._:-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "SL_htmltag" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DocumentationTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_TagWord"+          , Context+              { cName = "SL_TagWord"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[]^{|}"+                              }+                            (makeWordSet+                               False+                               [ "@a"+                               , "@addtogroup"+                               , "@anchor"+                               , "@b"+                               , "@c"+                               , "@class"+                               , "@cond"+                               , "@copydoc"+                               , "@def"+                               , "@dontinclude"+                               , "@dotfile"+                               , "@e"+                               , "@elseif"+                               , "@em"+                               , "@enum"+                               , "@example"+                               , "@exception"+                               , "@exceptions"+                               , "@file"+                               , "@htmlinclude"+                               , "@if"+                               , "@ifnot"+                               , "@include"+                               , "@link"+                               , "@namespace"+                               , "@p"+                               , "@package"+                               , "@ref"+                               , "@relates"+                               , "@relatesalso"+                               , "@retval"+                               , "@throw"+                               , "@throws"+                               , "@verbinclude"+                               , "@version"+                               , "@xrefitem"+                               , "\\a"+                               , "\\addtogroup"+                               , "\\anchor"+                               , "\\b"+                               , "\\c"+                               , "\\class"+                               , "\\cond"+                               , "\\copydoc"+                               , "\\def"+                               , "\\dontinclude"+                               , "\\dotfile"+                               , "\\e"+                               , "\\elseif"+                               , "\\em"+                               , "\\enum"+                               , "\\example"+                               , "\\exception"+                               , "\\exceptions"+                               , "\\file"+                               , "\\htmlinclude"+                               , "\\if"+                               , "\\ifnot"+                               , "\\include"+                               , "\\link"+                               , "\\namespace"+                               , "\\p"+                               , "\\package"+                               , "\\ref"+                               , "\\relates"+                               , "\\relatesalso"+                               , "\\retval"+                               , "\\throw"+                               , "\\throws"+                               , "\\verbinclude"+                               , "\\version"+                               , "\\xrefitem"+                               ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S(?=([][,?;()]|\\.$|\\.?\\s))"+                              , reCompiled =+                                  Just (compileRegex True "\\S(?=([][,?;()]|\\.$|\\.?\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DocumentationTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_TagWordString"+          , Context+              { cName = "SL_TagWordString"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S(?=([][,?;()]|\\.$|\\.?\\s))"+                              , reCompiled =+                                  Just (compileRegex True "\\S(?=([][,?;()]|\\.$|\\.?\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DocumentationTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_TagWordWord"+          , Context+              { cName = "SL_TagWordWord"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S(?=([][,?;()]|\\.$|\\.?\\s))"+                              , reCompiled =+                                  Just (compileRegex True "\\S(?=([][,?;()]|\\.$|\\.?\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "SL_Tag2ndWord" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DocumentationTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_htmlcomment"+          , Context+              { cName = "SL_htmlcomment"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "-->"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_htmltag"+          , Context+              { cName = "SL_htmltag"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*=\\s*"+                              , reCompiled = Just (compileRegex True "\\s*=\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "SL_identifiers" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_identifiers"+          , Context+              { cName = "SL_identifiers"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*#?[a-zA-Z0-9]*"+                              , reCompiled = Just (compileRegex True "\\s*#?[a-zA-Z0-9]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "SL_types1" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DoxygenLua" , "SL_types2" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_types1"+          , Context+              { cName = "SL_types1"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SL_types2"+          , Context+              { cName = "SL_types2"+              , cSyntax = "DoxygenLua"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Bruno Massa (brmassa@gmail.com)"+  , sVersion = "3"+  , sLicense = "LGPLv2+"+  , sExtensions = [ "*.dox" , "*.doxygen" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Dtd.hs view
@@ -0,0 +1,560 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Dtd (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "DTD"+  , sFilename = "dtd.xml"+  , sShortname = "Dtd"+  , sContexts =+      fromList+        [ ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "DTD"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "-->"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Declaration"+          , Context+              { cName = "Declaration"+              , cSyntax = "DTD"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DTD" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '-' '-'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DTD" , "InlineComment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DTD" , "String" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(-|O)\\s(-|O)"+                              , reCompiled = Just (compileRegex True "(-|O)\\s(-|O)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "(|),"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(%|&)(#[0-9]+|#[xX][0-9A-Fa-f]+|[\\-\\w\\d\\.:_]+);"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(%|&)(#[0-9]+|#[xX][0-9A-Fa-f]+|[\\-\\w\\d\\.:_]+);")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "?*+-&"+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%\\s"+                              , reCompiled = Just (compileRegex True "%\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ANY"+                               , "CDATA"+                               , "EMPTY"+                               , "ENTITIES"+                               , "ENTITY"+                               , "ID"+                               , "IDREF"+                               , "IDREFS"+                               , "NDATA"+                               , "NMTOKEN"+                               , "NMTOKENS"+                               , "NOTATION"+                               , "PUBLIC"+                               , "SYSTEM"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True [ "#FIXED" , "#IMPLIED" , "#PCDATA" , "#REQUIRED" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[\\-\\w\\d\\.:_]+\\b"+                              , reCompiled = Just (compileRegex True "\\b[\\-\\w\\d\\.:_]+\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "InlineComment"+          , Context+              { cName = "InlineComment"+              , cSyntax = "DTD"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '-' '-'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "DTD"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DTD" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<?xml"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DTD" , "PI" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<!ELEMENT"+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DTD" , "Declaration" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<!ATTLIST"+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DTD" , "Declaration" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<!NOTATION"+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DTD" , "Declaration" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<!ENTITY"+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "DTD" , "Declaration" ) ]+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "PI"+          , Context+              { cName = "PI"+              , cSyntax = "DTD"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '?' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "DTD"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%[\\-\\w\\d\\.:_]+;"+                              , reCompiled = Just (compileRegex True "%[\\-\\w\\d\\.:_]+;")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Andriy Lesyuk (s-andy@in.if.ua)"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions = [ "*.dtd" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Eiffel.hs view
@@ -0,0 +1,252 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Eiffel (syntax) where++import Skylighting.Types+import Data.Map+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Eiffel"+  , sFilename = "eiffel.xml"+  , sShortname = "Eiffel"+  , sContexts =+      fromList+        [ ( "Documentation"+          , Context+              { cName = "Documentation"+              , cSyntax = "Eiffel"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Eiffel"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "agent"+                               , "alias"+                               , "all"+                               , "and"+                               , "as"+                               , "assign"+                               , "class"+                               , "convert"+                               , "create"+                               , "creation"+                               , "debug"+                               , "deferred"+                               , "do"+                               , "else"+                               , "elseif"+                               , "end"+                               , "expanded"+                               , "export"+                               , "external"+                               , "feature"+                               , "from"+                               , "frozen"+                               , "if"+                               , "implies"+                               , "indexing"+                               , "infix"+                               , "inherit"+                               , "inspect"+                               , "is"+                               , "like"+                               , "local"+                               , "loop"+                               , "not"+                               , "obsolete"+                               , "old"+                               , "once"+                               , "or"+                               , "prefix"+                               , "pure"+                               , "redefine"+                               , "reference"+                               , "rename"+                               , "rescue"+                               , "retry"+                               , "separate"+                               , "then"+                               , "undefine"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Current"+                               , "False"+                               , "Precursor"+                               , "Result"+                               , "TUPLE"+                               , "True"+                               ])+                      , rAttribute = ConstantTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True [ "check" , "ensure" , "invariant" , "require" , "variant" ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Eiffel" , "Quoted String" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '-' '-'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Eiffel" , "Documentation" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Quoted String"+          , Context+              { cName = "Quoted String"+              , cSyntax = "Eiffel"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Sebastian Vuorinen"+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.e" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Elixir.hs view
@@ -0,0 +1,1221 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Elixir (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Elixir"+  , sFilename = "elixir.xml"+  , sShortname = "Elixir"+  , sContexts =+      fromList+        [ ( "Apostrophed String"+          , Context+              { cName = "Apostrophed String"+              , cSyntax = "Elixir"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "\\\\"+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\\\'"+                              , reCompiled = Just (compileRegex True "\\\\\\'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = VerbatimStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment Line"+          , Context+              { cName = "Comment Line"+              , cSyntax = "Elixir"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Documentation"+          , Context+              { cName = "Documentation"+              , cSyntax = "Elixir"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "\"\"\""+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*#+\\s.*[#]?$"+                              , reCompiled = Just (compileRegex True "\\s*#+\\s.*[#]?$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*[\\*\\+\\-]\\s"+                              , reCompiled = Just (compileRegex True "\\s*[\\*\\+\\-]\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*[\\d]+\\.\\s"+                              , reCompiled = Just (compileRegex True "\\s*[\\d]+\\.\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\`\\`\\`\\s*$"+                              , reCompiled = Just (compileRegex True "\\s*\\`\\`\\`\\s*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Elixir" , "Markdown Code" ) ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Markdown" , "Normal Text" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Find closing block brace"+          , Context+              { cName = "Find closing block brace"+              , cSyntax = "Elixir"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Elixir" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "General Comment"+          , Context+              { cName = "General Comment"+              , cSyntax = "Elixir"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Markdown Code"+          , Context+              { cName = "Markdown Code"+              , cSyntax = "Elixir"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\`\\`\\`\\s*$"+                              , reCompiled = Just (compileRegex True "\\s*\\`\\`\\`\\s*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Elixir"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#!\\/.*"+                              , reCompiled = Just (compileRegex True "#!\\/.*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&()*+,-./:;<=>[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "after"+                               , "and"+                               , "bc"+                               , "case"+                               , "do"+                               , "end"+                               , "exit"+                               , "for"+                               , "in"+                               , "inbits"+                               , "inlist"+                               , "lc"+                               , "not"+                               , "or"+                               , "quote"+                               , "receive"+                               , "super"+                               , "unquote"+                               , "when"+                               , "xor"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&()*+,-./:;<=>[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "catch"+                               , "cond"+                               , "else"+                               , "if"+                               , "raise"+                               , "rescue"+                               , "throw"+                               , "try"+                               , "unless"+                               ])+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&()*+,-./:;<=>[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "def"+                               , "defcallback"+                               , "defdelegate"+                               , "defexception"+                               , "defimpl"+                               , "defmacro"+                               , "defmacrocallback"+                               , "defmacrop"+                               , "defmodule"+                               , "defoverridable"+                               , "defp"+                               , "defprotocol"+                               , "defrecord"+                               , "defstruct"+                               , "fn"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&()*+,-./:;<=>[\\]^{|}~"+                              }+                            (makeWordSet True [ "false" , "nil" , "true" ])+                      , rAttribute = ConstantTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&()*+,-./:;<=>[\\]^{|}~"+                              }+                            (makeWordSet True [ "alias" , "import" , "require" , "use" ])+                      , rAttribute = ImportTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[_A-Z]+[A-Z_0-9]+\\b"+                              , reCompiled = Just (compileRegex True "\\b[_A-Z]+[A-Z_0-9]+\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ConstantTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[A-Z]+_*([0-9]|[a-z])[_a-zA-Z0-9]*\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex True "\\b[A-Z]+_*([0-9]|[a-z])[_a-zA-Z0-9]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ConstantTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b\\-?0[xX]([0-9a-fA-F]|_[0-9a-fA-F])+"+                              , reCompiled =+                                  Just (compileRegex True "\\b\\-?0[xX]([0-9a-fA-F]|_[0-9a-fA-F])+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b\\-?0[bB]([01]|_[01])+"+                              , reCompiled = Just (compileRegex True "\\b\\-?0[bB]([01]|_[01])+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b\\-?0[1-7]([0-7]|_[0-7])*"+                              , reCompiled =+                                  Just (compileRegex True "\\b\\-?0[1-7]([0-7]|_[0-7])*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b\\-?[0-9]([0-9]|_[0-9])*\\.[0-9]([0-9]|_[0-9])*([eE]\\-?[1-9]([0-9]|_[0-9])*(\\.[0-9]*)?)?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\b\\-?[0-9]([0-9]|_[0-9])*\\.[0-9]([0-9]|_[0-9])*([eE]\\-?[1-9]([0-9]|_[0-9])*(\\.[0-9]*)?)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b\\-?[1-9]([0-9]|_[0-9])*\\b"+                              , reCompiled =+                                  Just (compileRegex True "\\b\\-?[1-9]([0-9]|_[0-9])*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '.'+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '&' '&'+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '|' '|'+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s[\\?\\:\\%]\\s"+                              , reCompiled = Just (compileRegex True "\\s[\\?\\:\\%]\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[|&<>\\^\\+*~\\-=/]+"+                              , reCompiled = Just (compileRegex True "[|&<>\\^\\+*~\\-=/]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s!"+                              , reCompiled = Just (compileRegex True "\\s!")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/=\\s"+                              , reCompiled = Just (compileRegex True "/=\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "%="+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ":(@{1,2}|\\$)?[a-zA-Z_][a-zA-Z0-9_]*[=?!]?"+                              , reCompiled =+                                  Just+                                    (compileRegex True ":(@{1,2}|\\$)?[a-zA-Z_][a-zA-Z0-9_]*[=?!]?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(@{1,2}|\\$)?[a-zA-Z_][a-zA-Z0-9_]*[=?!]?:"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\b(@{1,2}|\\$)?[a-zA-Z_][a-zA-Z0-9_]*[=?!]?:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ":\\[\\]=?"+                              , reCompiled = Just (compileRegex True ":\\[\\]=?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@(module)?doc\\s+\"\"\""+                              , reCompiled = Just (compileRegex True "@(module)?doc\\s+\"\"\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Elixir" , "Documentation" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "\"\"\""+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Elixir" , "Triple Quoted String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Elixir" , "Quoted String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Elixir" , "Apostrophed String" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "?#"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Elixir" , "General Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@[a-zA-Z_0-9]+"+                              , reCompiled = Just (compileRegex True "@[a-zA-Z_0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Quoted String"+          , Context+              { cName = "Quoted String"+              , cSyntax = "Elixir"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "\\\\"+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\\\\""+                              , reCompiled = Just (compileRegex True "\\\\\\\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#@{1,2}"+                              , reCompiled = Just (compileRegex True "#@{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Elixir" , "Short Subst" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Elixir" , "Subst" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Short Subst"+          , Context+              { cName = "Short Subst"+              , cSyntax = "Elixir"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#@{1,2}"+                              , reCompiled = Just (compileRegex True "#@{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\w(?!\\w)"+                              , reCompiled = Just (compileRegex True "\\w(?!\\w)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Subst"+          , Context+              { cName = "Subst"+              , cSyntax = "Elixir"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Elixir" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Triple Quoted String"+          , Context+              { cName = "Triple Quoted String"+              , cSyntax = "Elixir"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "\"\"\""+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "regexpr_rules"+          , Context+              { cName = "regexpr_rules"+              , cSyntax = "Elixir"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#@{1,2}"+                              , reCompiled = Just (compileRegex True "#@{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Elixir" , "Short Subst" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Elixir" , "Subst" ) ]+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor =+      "Rub\233n Caro (ruben.caro.estevez@gmail.com), Boris Egorov (egorov@linux.com)"+  , sVersion = "2"+  , sLicense = "LGPLv2+"+  , sExtensions =+      [ "*.ex" , "*.exs" , "*.eex" , "*.xml.eex" , "*.js.eex" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Email.hs view
@@ -0,0 +1,1109 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Email (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex++syntax :: Syntax+syntax = Syntax+  { sName = "Email"+  , sFilename = "email.xml"+  , sShortname = "Email"+  , sContexts =+      fromList+        [ ( "headder"+          , Context+              { cName = "headder"+              , cSyntax = "Email"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Tt]o:.*$"+                              , reCompiled = Just (compileRegex False "[Tt]o:.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Ff]rom:.*$"+                              , reCompiled = Just (compileRegex False "[Ff]rom:.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Cc][Cc]:.*$"+                              , reCompiled = Just (compileRegex False "[Cc][Cc]:.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Bb][Cc][Cc]:.*$"+                              , reCompiled = Just (compileRegex False "[Bb][Cc][Cc]:.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Ss]ubject:.*$"+                              , reCompiled = Just (compileRegex False "[Ss]ubject:.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Dd]ate:.*$"+                              , reCompiled = Just (compileRegex False "[Dd]ate:.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Ss]ender:"+                              , reCompiled = Just (compileRegex False "[Ss]ender:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Rr]eply-[Tt]o:"+                              , reCompiled = Just (compileRegex False "[Rr]eply-[Tt]o:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Mm]essage-[Ii][Dd]:"+                              , reCompiled = Just (compileRegex False "[Mm]essage-[Ii][Dd]:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Ii]n-[Rr]eply-[Tt]o:"+                              , reCompiled = Just (compileRegex False "[Ii]n-[Rr]eply-[Tt]o:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Rr]eferences:"+                              , reCompiled = Just (compileRegex False "[Rr]eferences:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Cc]omments:"+                              , reCompiled = Just (compileRegex False "[Cc]omments:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Kk]eywors:"+                              , reCompiled = Just (compileRegex False "[Kk]eywors:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Rr]esent-[Dd]ate:"+                              , reCompiled = Just (compileRegex False "[Rr]esent-[Dd]ate:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Rr]esent-[Ff]rom:"+                              , reCompiled = Just (compileRegex False "[Rr]esent-[Ff]rom:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Rr]esent-[Ss]ender:"+                              , reCompiled = Just (compileRegex False "[Rr]esent-[Ss]ender:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Rr]esent-[Tt]o:"+                              , reCompiled = Just (compileRegex False "[Rr]esent-[Tt]o:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Rr]esent-[Cc][Cc]:"+                              , reCompiled = Just (compileRegex False "[Rr]esent-[Cc][Cc]:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Rr]esent-[Bb][Cc][Cc]:"+                              , reCompiled = Just (compileRegex False "[Rr]esent-[Bb][Cc][Cc]:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Rr]esent-[Mm]essage-[Ii][Dd]:"+                              , reCompiled =+                                  Just (compileRegex False "[Rr]esent-[Mm]essage-[Ii][Dd]:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Rr]esent-[Rr]eply-[Tt]o:"+                              , reCompiled =+                                  Just (compileRegex False "[Rr]esent-[Rr]eply-[Tt]o:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Rr]eturn-[Pp]ath:"+                              , reCompiled = Just (compileRegex False "[Rr]eturn-[Pp]ath:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Rr]eceived:"+                              , reCompiled = Just (compileRegex False "[Rr]eceived:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Xx]-[Mm]ozilla-[Ss]tatus:"+                              , reCompiled =+                                  Just (compileRegex False "[Xx]-[Mm]ozilla-[Ss]tatus:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Xx]-[Mm]ozilla-[Ss]tatus2:"+                              , reCompiled =+                                  Just (compileRegex False "[Xx]-[Mm]ozilla-[Ss]tatus2:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Ee]nverlope-[Tt]o:"+                              , reCompiled = Just (compileRegex False "[Ee]nverlope-[Tt]o:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Dd]elivery-[Dd]ate:"+                              , reCompiled = Just (compileRegex False "[Dd]elivery-[Dd]ate:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Xx]-[Oo]riginating-[Ii][Pp]:"+                              , reCompiled =+                                  Just (compileRegex False "[Xx]-[Oo]riginating-[Ii][Pp]:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Xx]-[Oo]riginating-[Ee]mail:"+                              , reCompiled =+                                  Just (compileRegex False "[Xx]-[Oo]riginating-[Ee]mail:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Xx]-[Ss]ender:"+                              , reCompiled = Just (compileRegex False "[Xx]-[Ss]ender:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Mm]ime-[Vv]ersion:"+                              , reCompiled = Just (compileRegex False "[Mm]ime-[Vv]ersion:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Cc]ontent-[Tt]ype:"+                              , reCompiled = Just (compileRegex False "[Cc]ontent-[Tt]ype:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Xx]-[Mm]ailing-[Ll]ist:"+                              , reCompiled = Just (compileRegex False "[Xx]-[Mm]ailing-[Ll]ist:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Xx]-[Ll]oop:"+                              , reCompiled = Just (compileRegex False "[Xx]-[Ll]oop:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Ll]ist-[Pp]ost:"+                              , reCompiled = Just (compileRegex False "[Ll]ist-[Pp]ost:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Ll]ist-[Hh]elp:"+                              , reCompiled = Just (compileRegex False "[Ll]ist-[Hh]elp:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Ll]ist-[Uu]nsubscribe:"+                              , reCompiled = Just (compileRegex False "[Ll]ist-[Uu]nsubscribe:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Pp]recedence:"+                              , reCompiled = Just (compileRegex False "[Pp]recedence:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Cc]ontent-[Tt]ransfer-[Ee]ncoding:"+                              , reCompiled =+                                  Just (compileRegex False "[Cc]ontent-[Tt]ransfer-[Ee]ncoding:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Cc]ontent-[Tt]ype:"+                              , reCompiled = Just (compileRegex False "[Cc]ontent-[Tt]ype:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Xx]-[Bb]ulkmail:"+                              , reCompiled = Just (compileRegex False "[Xx]-[Bb]ulkmail:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Pp]recedence:"+                              , reCompiled = Just (compileRegex False "[Pp]recedence:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[Cc]ontent-[Dd]isposition:"+                              , reCompiled =+                                  Just (compileRegex False "[Cc]ontent-[Dd]isposition:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[0-9a-zA-Z-.]+:"+                              , reCompiled = Just (compileRegex False "[0-9a-zA-Z-.]+:")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z0-9.\\-]+\\@[a-zA-Z0-9.\\-]+"+                              , reCompiled =+                                  Just (compileRegex False "[a-zA-Z0-9.\\-]+\\@[a-zA-Z0-9.\\-]+")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "[a-zA-Z0-9.\\-]*\\s*<[a-zA-Z0-9.\\-]+\\@[a-zA-Z0-9.\\-]+>"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "[a-zA-Z0-9.\\-]*\\s*<[a-zA-Z0-9.\\-]+\\@[a-zA-Z0-9.\\-]+>")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\"[a-zA-Z0-9. \\-]+\"\\s*<[a-zA-Z0-9.\\-]+\\@[a-zA-Z0-9.\\-]+>"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "\"[a-zA-Z0-9. \\-]+\"\\s*<[a-zA-Z0-9.\\-]+\\@[a-zA-Z0-9.\\-]+>")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\".*\""+                              , reCompiled = Just (compileRegex False "\".*\"")+                              , reCaseSensitive = False+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'.*'"+                              , reCompiled = Just (compileRegex False "'.*'")+                              , reCaseSensitive = False+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[|>]\\s*[|>]\\s*[|>]\\s*[|>]\\s*[|>]\\s*[|>].*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False "[|>]\\s*[|>]\\s*[|>]\\s*[|>]\\s*[|>]\\s*[|>].*")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[|>]\\s*[|>]\\s*[|>]\\s*[|>]\\s*[|>].*"+                              , reCompiled =+                                  Just (compileRegex False "[|>]\\s*[|>]\\s*[|>]\\s*[|>]\\s*[|>].*")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[|>]\\s*[|>]\\s*[|>]\\s*[|>].*"+                              , reCompiled =+                                  Just (compileRegex False "[|>]\\s*[|>]\\s*[|>]\\s*[|>].*")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[|>]\\s*[|>]\\s*[|>].*"+                              , reCompiled = Just (compileRegex False "[|>]\\s*[|>]\\s*[|>].*")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[|>]\\s*[|>].*"+                              , reCompiled = Just (compileRegex False "[|>]\\s*[|>].*")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[|>].*"+                              , reCompiled = Just (compileRegex False "[|>].*")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "([A-Za-z0-9+/][A-Za-z0-9+/][A-Za-z0-9+/][A-Za-z0-9+/]){10,20}$"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "([A-Za-z0-9+/][A-Za-z0-9+/][A-Za-z0-9+/][A-Za-z0-9+/]){10,20}$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Za-z0-9+=/]+=$"+                              , reCompiled = Just (compileRegex False "[A-Za-z0-9+=/]+=$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(- )?--(--.*)?"+                              , reCompiled = Just (compileRegex False "(- )?--(--.*)?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Carl A Joslin (carl.joslin@joslin.dyndns.org)"+  , sVersion = "2"+  , sLicense = "GPL"+  , sExtensions = [ "*.eml" ]+  , sStartingContext = "headder"+  }
+ src/Skylighting/Syntax/Erlang.hs view
@@ -0,0 +1,643 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Erlang (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Erlang"+  , sFilename = "erlang.xml"+  , sShortname = "Erlang"+  , sContexts =+      fromList+        [ ( "Normal Text"+          , Context+              { cName = "Normal Text"+              , cSyntax = "Erlang"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(?:-module|-export|-define|-undef|-ifdef|-ifndef|-else|-endif|-include|-include_lib)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(?:-module|-export|-define|-undef|-ifdef|-ifndef|-else|-endif|-include|-include_lib)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "after"+                               , "all_true"+                               , "begin"+                               , "case"+                               , "catch"+                               , "cond"+                               , "end"+                               , "fun"+                               , "if"+                               , "let"+                               , "of"+                               , "query"+                               , "receive"+                               , "some_true"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "and"+                               , "band"+                               , "bnot"+                               , "bor"+                               , "bsl"+                               , "bsr"+                               , "bxor"+                               , "div"+                               , "not"+                               , "or"+                               , "rem"+                               , "xor"+                               ])+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(?:\\+|-|\\*|\\/|==|\\/=|=:=|=\\/=|<|=<|>|>=|\\+\\+|--|=|!|<-)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(?:\\+|-|\\*|\\/|==|\\/=|=:=|=\\/=|<|=<|>|>=|\\+\\+|--|=|!|<-)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "abs"+                               , "accept"+                               , "alarm"+                               , "apply"+                               , "atom_to_list"+                               , "binary_to_list"+                               , "binary_to_term"+                               , "check_process_code"+                               , "concat_binary"+                               , "date"+                               , "delete_module"+                               , "disconnect_node"+                               , "element"+                               , "erase"+                               , "exit"+                               , "float"+                               , "float_to_list"+                               , "garbage_collect"+                               , "get"+                               , "get_keys"+                               , "group_leader"+                               , "halt"+                               , "hd"+                               , "integer_to_list"+                               , "is_alive"+                               , "is_atom"+                               , "is_binary"+                               , "is_boolean"+                               , "is_float"+                               , "is_function"+                               , "is_integer"+                               , "is_list"+                               , "is_number"+                               , "is_pid"+                               , "is_port"+                               , "is_process_alive"+                               , "is_record"+                               , "is_reference"+                               , "is_tuple"+                               , "length"+                               , "link"+                               , "list_to_atom"+                               , "list_to_binary"+                               , "list_to_float"+                               , "list_to_integer"+                               , "list_to_pid"+                               , "list_to_tuple"+                               , "load_module"+                               , "loaded"+                               , "localtime"+                               , "make_ref"+                               , "module_loaded"+                               , "node"+                               , "nodes"+                               , "now"+                               , "open_port"+                               , "pid_to_list"+                               , "port_close"+                               , "port_command"+                               , "port_connect"+                               , "port_control"+                               , "ports"+                               , "pre_loaded"+                               , "process_flag"+                               , "process_info"+                               , "processes"+                               , "purge_module"+                               , "put"+                               , "register"+                               , "registered"+                               , "round"+                               , "self"+                               , "setelement"+                               , "size"+                               , "spawn"+                               , "spawn_link"+                               , "spawn_opt"+                               , "split_binary"+                               , "statistics"+                               , "term_to_binary"+                               , "throw"+                               , "time"+                               , "tl"+                               , "trunc"+                               , "tuple_to_list"+                               , "unlink"+                               , "unregister"+                               , "whereis"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(?:\\(|\\)|\\{|\\}|\\[|\\]|\\.|\\:|\\||\\|\\||;|\\,|\\?|->|\\#)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(?:\\(|\\)|\\{|\\}|\\[|\\]|\\.|\\:|\\||\\|\\||;|\\,|\\?|->|\\#)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Erlang" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b[a-z][_a-z@-Z0-9]*(?:(?=[^_a-z@-Z0-9])|$):\\b[a-z][_a-z@-Z0-9]*(?:(?=[^_a-z@-Z0-9])|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\b[a-z][_a-z@-Z0-9]*(?:(?=[^_a-z@-Z0-9])|$):\\b[a-z][_a-z@-Z0-9]*(?:(?=[^_a-z@-Z0-9])|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[a-z][_a-z@-Z0-9]*(?:(?=[^_a-z@-Z0-9])|$)\\("+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\b[a-z][_a-z@-Z0-9]*(?:(?=[^_a-z@-Z0-9])|$)\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Erlang" , "isfunction" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[_A-Z][_a-z@-Z0-9]*(?:(?=[^_a-z@-Z0-9])|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\b[_A-Z][_a-z@-Z0-9]*(?:(?=[^_a-z@-Z0-9])|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Erlang" , "atomquote" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[a-z][_a-z@-Z0-9]*(?:(?=[^_a-z@-Z0-9])|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\b[a-z][_a-z@-Z0-9]*(?:(?=[^_a-z@-Z0-9])|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Erlang" , "stringquote" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[0-9]+\\.[0-9]+(?:[eE][+-]?[0-9]+)?"+                              , reCompiled =+                                  Just (compileRegex True "[0-9]+\\.[0-9]+(?:[eE][+-]?[0-9]+)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\d+#[a-zA-Z0-9]+"+                              , reCompiled = Just (compileRegex True "\\d+#[a-zA-Z0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\S"+                              , reCompiled = Just (compileRegex True "\\$\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[0-9]+"+                              , reCompiled = Just (compileRegex True "[0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "atomquote"+          , Context+              { cName = "atomquote"+              , cSyntax = "Erlang"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(?:(?:\\\\')?[^']*)*'"+                              , reCompiled = Just (compileRegex True "(?:(?:\\\\')?[^']*)*'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "comment"+          , Context+              { cName = "comment"+              , cSyntax = "Erlang"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "isfunction"+          , Context+              { cName = "isfunction"+              , cSyntax = "Erlang"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[a-z][_a-z@-Z0-9]*(?:(?=[^_a-z@-Z0-9])|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\b[a-z][_a-z@-Z0-9]*(?:(?=[^_a-z@-Z0-9])|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "stringquote"+          , Context+              { cName = "stringquote"+              , cSyntax = "Erlang"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(?:(?:\\\\\")?[^\"]*)*\""+                              , reCompiled = Just (compileRegex True "(?:(?:\\\\\")?[^\"]*)*\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Bill Ross (bill@emailme.net.au)"+  , sVersion = "3"+  , sLicense = "LGPLv2"+  , sExtensions = [ "*.erl" ]+  , sStartingContext = "Normal Text"+  }
+ src/Skylighting/Syntax/Fasm.hs view
@@ -0,0 +1,1181 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Fasm (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Intel x86 (FASM)"+  , sFilename = "fasm.xml"+  , sShortname = "Fasm"+  , sContexts =+      fromList+        [ ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "Intel x86 (FASM)"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Intel x86 (FASM)"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "ah"+                               , "al"+                               , "ax"+                               , "bh"+                               , "bl"+                               , "bp"+                               , "bx"+                               , "ch"+                               , "cl"+                               , "cr0"+                               , "cr2"+                               , "cr3"+                               , "cr4"+                               , "cs"+                               , "cx"+                               , "dh"+                               , "di"+                               , "dl"+                               , "dr0"+                               , "dr1"+                               , "dr2"+                               , "dr3"+                               , "dr6"+                               , "dr7"+                               , "ds"+                               , "dx"+                               , "eax"+                               , "ebp"+                               , "ebx"+                               , "ecx"+                               , "edi"+                               , "edx"+                               , "es"+                               , "esi"+                               , "esp"+                               , "fs"+                               , "gs"+                               , "mm0"+                               , "mm1"+                               , "mm2"+                               , "mm3"+                               , "mm4"+                               , "mm5"+                               , "mm6"+                               , "mm7"+                               , "r10"+                               , "r11"+                               , "r12"+                               , "r13"+                               , "r14"+                               , "r15"+                               , "r8"+                               , "r9"+                               , "rax"+                               , "rbp"+                               , "rbx"+                               , "rcx"+                               , "rdi"+                               , "rdx"+                               , "rsi"+                               , "rsp"+                               , "si"+                               , "sp"+                               , "ss"+                               , "st"+                               , "xmm0"+                               , "xmm1"+                               , "xmm2"+                               , "xmm3"+                               , "xmm4"+                               , "xmm5"+                               , "xmm6"+                               , "xmm7"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "byte"+                               , "db"+                               , "dd"+                               , "df"+                               , "dp"+                               , "dq"+                               , "dqword"+                               , "dt"+                               , "du"+                               , "dw"+                               , "dword"+                               , "file"+                               , "ptr"+                               , "pword"+                               , "qword"+                               , "rb"+                               , "rd"+                               , "rf"+                               , "rp"+                               , "rq"+                               , "rt"+                               , "rw"+                               , "tbyte"+                               , "tword"+                               , "word"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "aaa"+                               , "aad"+                               , "aam"+                               , "aas"+                               , "adc"+                               , "add"+                               , "addpd"+                               , "addps"+                               , "addsd"+                               , "addss"+                               , "addsubpd"+                               , "addsubps"+                               , "and"+                               , "andnpd"+                               , "andnps"+                               , "andpd"+                               , "andps"+                               , "arpl"+                               , "bound"+                               , "bsf"+                               , "bsr"+                               , "bswap"+                               , "bt"+                               , "btc"+                               , "btr"+                               , "bts"+                               , "call"+                               , "cbw"+                               , "cdq"+                               , "cdqe"+                               , "clc"+                               , "cld"+                               , "clflush"+                               , "clgi"+                               , "cli"+                               , "clts"+                               , "cmc"+                               , "cmova"+                               , "cmovae"+                               , "cmovb"+                               , "cmovbe"+                               , "cmovc"+                               , "cmove"+                               , "cmovg"+                               , "cmovge"+                               , "cmovl"+                               , "cmovle"+                               , "cmovna"+                               , "cmovnae"+                               , "cmovnb"+                               , "cmovnbe"+                               , "cmovnc"+                               , "cmovne"+                               , "cmovng"+                               , "cmovnge"+                               , "cmovnl"+                               , "cmovnle"+                               , "cmovno"+                               , "cmovnp"+                               , "cmovns"+                               , "cmovnz"+                               , "cmovo"+                               , "cmovp"+                               , "cmovpe"+                               , "cmovpo"+                               , "cmovs"+                               , "cmovz"+                               , "cmp"+                               , "cmpeqpd"+                               , "cmpeqps"+                               , "cmpeqsd"+                               , "cmpeqss"+                               , "cmplepd"+                               , "cmpleps"+                               , "cmplesd"+                               , "cmpless"+                               , "cmpltpd"+                               , "cmpltps"+                               , "cmpltsd"+                               , "cmpltss"+                               , "cmpneqpd"+                               , "cmpneqps"+                               , "cmpneqsd"+                               , "cmpneqss"+                               , "cmpnlepd"+                               , "cmpnleps"+                               , "cmpnlesd"+                               , "cmpnless"+                               , "cmpnltpd"+                               , "cmpnltps"+                               , "cmpnltsd"+                               , "cmpnltss"+                               , "cmpordpd"+                               , "cmpordps"+                               , "cmpordsd"+                               , "cmpordss"+                               , "cmppd"+                               , "cmpps"+                               , "cmps"+                               , "cmpsb"+                               , "cmpsd"+                               , "cmpss"+                               , "cmpsw"+                               , "cmpunordpd"+                               , "cmpunordps"+                               , "cmpunordsd"+                               , "cmpunordss"+                               , "cmpxchg"+                               , "cmpxchg16b"+                               , "cmpxchg486"+                               , "cmpxchg8b"+                               , "comisd"+                               , "comiss"+                               , "cpuid"+                               , "cqo"+                               , "cvtdq2pd"+                               , "cvtdq2ps"+                               , "cvtpd2dq"+                               , "cvtpd2pi"+                               , "cvtpd2ps"+                               , "cvtpi2pd"+                               , "cvtpi2ps"+                               , "cvtps2dq"+                               , "cvtps2pd"+                               , "cvtps2pi"+                               , "cvtsd2si"+                               , "cvtsd2ss"+                               , "cvtsi2sd"+                               , "cvtsi2ss"+                               , "cvtss2sd"+                               , "cvtss2si"+                               , "cvttpd2dq"+                               , "cvttpd2pi"+                               , "cvttps2dq"+                               , "cvttps2pi"+                               , "cvttsd2si"+                               , "cvttss2si"+                               , "cwd"+                               , "cwde"+                               , "daa"+                               , "das"+                               , "dec"+                               , "div"+                               , "divpd"+                               , "divps"+                               , "divsd"+                               , "divss"+                               , "emms"+                               , "enter"+                               , "f2xm1"+                               , "fabs"+                               , "fadd"+                               , "faddp"+                               , "fbld"+                               , "fbstp"+                               , "fchs"+                               , "fclex"+                               , "fcmovb"+                               , "fcmovbe"+                               , "fcmove"+                               , "fcmovnb"+                               , "fcmovnbe"+                               , "fcmovne"+                               , "fcmovnu"+                               , "fcmovu"+                               , "fcom"+                               , "fcomi"+                               , "fcomip"+                               , "fcomp"+                               , "fcompp"+                               , "fcos"+                               , "fdecstp"+                               , "fdisi"+                               , "fdiv"+                               , "fdivp"+                               , "fdivr"+                               , "fdivrp"+                               , "femms"+                               , "feni"+                               , "ffree"+                               , "ffreep"+                               , "fiadd"+                               , "ficom"+                               , "ficomp"+                               , "fidiv"+                               , "fidivr"+                               , "fild"+                               , "fimul"+                               , "fincstp"+                               , "finit"+                               , "fist"+                               , "fistp"+                               , "fisttp"+                               , "fisub"+                               , "fisubr"+                               , "fld"+                               , "fld1"+                               , "fldcw"+                               , "fldenv"+                               , "fldl2e"+                               , "fldl2t"+                               , "fldlg2"+                               , "fldln2"+                               , "fldpi"+                               , "fldz"+                               , "fmul"+                               , "fmulp"+                               , "fnclex"+                               , "fndisi"+                               , "fneni"+                               , "fninit"+                               , "fnop"+                               , "fnsave"+                               , "fnstcw"+                               , "fnstenv"+                               , "fnstsw"+                               , "fnwait"+                               , "fpatan"+                               , "fprem"+                               , "fprem1"+                               , "fptan"+                               , "frndint"+                               , "frstor"+                               , "fsave"+                               , "fscale"+                               , "fsetpm"+                               , "fsin"+                               , "fsincos"+                               , "fsqrt"+                               , "fst"+                               , "fstcw"+                               , "fstenv"+                               , "fstp"+                               , "fstsw"+                               , "fsub"+                               , "fsubp"+                               , "fsubr"+                               , "fsubrp"+                               , "ftst"+                               , "fucom"+                               , "fucomi"+                               , "fucomip"+                               , "fucomp"+                               , "fucompp"+                               , "fwait"+                               , "fxam"+                               , "fxch"+                               , "fxrstor"+                               , "fxsave"+                               , "fxtract"+                               , "fyl2x"+                               , "fyl2xp1"+                               , "haddpd"+                               , "haddps"+                               , "hlt"+                               , "hsubpd"+                               , "hsubps"+                               , "ibts"+                               , "idiv"+                               , "imul"+                               , "in"+                               , "inc"+                               , "ins"+                               , "insb"+                               , "insd"+                               , "insw"+                               , "int"+                               , "int1"+                               , "int3"+                               , "into"+                               , "invd"+                               , "invlpg"+                               , "invlpga"+                               , "iret"+                               , "iretd"+                               , "iretq"+                               , "iretw"+                               , "ja"+                               , "jae"+                               , "jb"+                               , "jbe"+                               , "jc"+                               , "jcxz"+                               , "je"+                               , "jecxz"+                               , "jg"+                               , "jge"+                               , "jl"+                               , "jle"+                               , "jmp"+                               , "jna"+                               , "jnae"+                               , "jnb"+                               , "jnbe"+                               , "jnc"+                               , "jne"+                               , "jng"+                               , "jnge"+                               , "jnl"+                               , "jnle"+                               , "jno"+                               , "jnp"+                               , "jns"+                               , "jnz"+                               , "jo"+                               , "jp"+                               , "jpe"+                               , "jpo"+                               , "jrcxz"+                               , "js"+                               , "jz"+                               , "lahf"+                               , "lar"+                               , "lddqu"+                               , "ldmxcsr"+                               , "lds"+                               , "lea"+                               , "leave"+                               , "les"+                               , "lfence"+                               , "lfs"+                               , "lgdt"+                               , "lgs"+                               , "lidt"+                               , "lldt"+                               , "lmsw"+                               , "loadall"+                               , "loadall286"+                               , "lods"+                               , "lodsb"+                               , "lodsd"+                               , "lodsq"+                               , "lodsw"+                               , "loop"+                               , "loope"+                               , "loopne"+                               , "loopnz"+                               , "loopz"+                               , "lsl"+                               , "lss"+                               , "ltr"+                               , "maskmovdqu"+                               , "maskmovq"+                               , "maxpd"+                               , "maxps"+                               , "maxsd"+                               , "maxss"+                               , "mfence"+                               , "minpd"+                               , "minps"+                               , "minsd"+                               , "minss"+                               , "monitor"+                               , "mov"+                               , "movapd"+                               , "movaps"+                               , "movd"+                               , "movddup"+                               , "movdq2q"+                               , "movdqa"+                               , "movdqu"+                               , "movhlps"+                               , "movhpd"+                               , "movhps"+                               , "movlhps"+                               , "movlpd"+                               , "movlps"+                               , "movmskpd"+                               , "movmskps"+                               , "movntdq"+                               , "movnti"+                               , "movntpd"+                               , "movntps"+                               , "movntq"+                               , "movq"+                               , "movq2dq"+                               , "movs"+                               , "movsb"+                               , "movsd"+                               , "movshdup"+                               , "movsldup"+                               , "movsq"+                               , "movss"+                               , "movsw"+                               , "movsx"+                               , "movsxd"+                               , "movupd"+                               , "movups"+                               , "movzx"+                               , "mul"+                               , "mulpd"+                               , "mulps"+                               , "mulsd"+                               , "mulss"+                               , "mwait"+                               , "neg"+                               , "nop"+                               , "not"+                               , "or"+                               , "orpd"+                               , "orps"+                               , "out"+                               , "outs"+                               , "outsb"+                               , "outsd"+                               , "outsw"+                               , "packssdw"+                               , "packsswb"+                               , "packuswb"+                               , "paddb"+                               , "paddd"+                               , "paddq"+                               , "paddsb"+                               , "paddsw"+                               , "paddusb"+                               , "paddusw"+                               , "paddw"+                               , "pand"+                               , "pandn"+                               , "pause"+                               , "pavgb"+                               , "pavgusb"+                               , "pavgw"+                               , "pcmpeqb"+                               , "pcmpeqd"+                               , "pcmpeqw"+                               , "pcmpgtb"+                               , "pcmpgtd"+                               , "pcmpgtw"+                               , "pdistib"+                               , "pextrw"+                               , "pf2id"+                               , "pf2iw"+                               , "pfacc"+                               , "pfadd"+                               , "pfcmpeq"+                               , "pfcmpge"+                               , "pfcmpgt"+                               , "pfmax"+                               , "pfmin"+                               , "pfmul"+                               , "pfnacc"+                               , "pfpnacc"+                               , "pfrcp"+                               , "pfrcpit1"+                               , "pfrcpit2"+                               , "pfrsqit1"+                               , "pfrsqrt"+                               , "pfsub"+                               , "pfsubr"+                               , "pi2fd"+                               , "pi2fw"+                               , "pinsrw"+                               , "pmachriw"+                               , "pmaddwd"+                               , "pmagw"+                               , "pmaxsw"+                               , "pmaxub"+                               , "pminsw"+                               , "pminub"+                               , "pmovmskb"+                               , "pmulhrw"+                               , "pmulhuw"+                               , "pmulhw"+                               , "pmullw"+                               , "pmuludq"+                               , "pmvgezb"+                               , "pmvlzb"+                               , "pmvnzb"+                               , "pmvzb"+                               , "pop"+                               , "popa"+                               , "popad"+                               , "popaw"+                               , "popf"+                               , "popfd"+                               , "popfq"+                               , "popfw"+                               , "por"+                               , "prefetch"+                               , "prefetchnta"+                               , "prefetcht0"+                               , "prefetcht1"+                               , "prefetcht2"+                               , "prefetchw"+                               , "psadbw"+                               , "pshufd"+                               , "pshufhw"+                               , "pshuflw"+                               , "pshufw"+                               , "pslld"+                               , "pslldq"+                               , "psllq"+                               , "psllw"+                               , "psrad"+                               , "psraw"+                               , "psrld"+                               , "psrldq"+                               , "psrlq"+                               , "psrlw"+                               , "psubb"+                               , "psubd"+                               , "psubq"+                               , "psubsb"+                               , "psubsiw"+                               , "psubsw"+                               , "psubusb"+                               , "psubusw"+                               , "psubw"+                               , "pswapd"+                               , "punpckhbw"+                               , "punpckhdq"+                               , "punpckhqdq"+                               , "punpckhwd"+                               , "punpcklbw"+                               , "punpckldq"+                               , "punpcklqdq"+                               , "punpcklwd"+                               , "push"+                               , "pusha"+                               , "pushad"+                               , "pushaw"+                               , "pushf"+                               , "pushfd"+                               , "pushfq"+                               , "pushfw"+                               , "pxor"+                               , "rcl"+                               , "rcpps"+                               , "rcpss"+                               , "rcr"+                               , "rdmsr"+                               , "rdpmc"+                               , "rdshr"+                               , "rdtsc"+                               , "rdtscp"+                               , "ret"+                               , "retf"+                               , "retn"+                               , "rol"+                               , "ror"+                               , "rsdc"+                               , "rsldt"+                               , "rsm"+                               , "rsqrtps"+                               , "rsqrtss"+                               , "rsts"+                               , "sahf"+                               , "sal"+                               , "salc"+                               , "sar"+                               , "sbb"+                               , "scas"+                               , "scasb"+                               , "scasd"+                               , "scasq"+                               , "scasw"+                               , "seta"+                               , "setae"+                               , "setb"+                               , "setbe"+                               , "setc"+                               , "sete"+                               , "setg"+                               , "setge"+                               , "setl"+                               , "setle"+                               , "setna"+                               , "setnae"+                               , "setnb"+                               , "setnbe"+                               , "setnc"+                               , "setne"+                               , "setng"+                               , "setnge"+                               , "setnl"+                               , "setnle"+                               , "setno"+                               , "setnp"+                               , "setns"+                               , "setnz"+                               , "seto"+                               , "setp"+                               , "setpe"+                               , "setpo"+                               , "sets"+                               , "setz"+                               , "sfence"+                               , "sgdt"+                               , "shl"+                               , "shld"+                               , "shr"+                               , "shrd"+                               , "shufpd"+                               , "shufps"+                               , "sidt"+                               , "skinit"+                               , "sldt"+                               , "smi"+                               , "smint"+                               , "smintold"+                               , "smsw"+                               , "sqrtpd"+                               , "sqrtps"+                               , "sqrtsd"+                               , "sqrtss"+                               , "stc"+                               , "std"+                               , "stgi"+                               , "sti"+                               , "stmxcsr"+                               , "stos"+                               , "stosb"+                               , "stosd"+                               , "stosq"+                               , "stosw"+                               , "str"+                               , "sub"+                               , "subpd"+                               , "subps"+                               , "subsd"+                               , "subss"+                               , "svdc"+                               , "svldt"+                               , "svts"+                               , "swapgs"+                               , "syscall"+                               , "sysenter"+                               , "sysexit"+                               , "sysret"+                               , "test"+                               , "ucomisd"+                               , "ucomiss"+                               , "ud0"+                               , "ud1"+                               , "ud2"+                               , "umov"+                               , "unpckhpd"+                               , "unpckhps"+                               , "unpcklpd"+                               , "unpcklps"+                               , "verr"+                               , "verw"+                               , "vmload"+                               , "vmmcall"+                               , "vmrun"+                               , "vmsave"+                               , "wait"+                               , "wbinvd"+                               , "wrmsr"+                               , "wrshr"+                               , "xadd"+                               , "xbts"+                               , "xchg"+                               , "xlat"+                               , "xlatb"+                               , "xor"+                               , "xorpd"+                               , "xorps"+                               ])+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "align"+                               , "data"+                               , "entry"+                               , "extrn"+                               , "format"+                               , "from"+                               , "heap"+                               , "include"+                               , "invoke"+                               , "load"+                               , "org"+                               , "proc"+                               , "public"+                               , "section"+                               , "segment"+                               , "stack"+                               , "store"+                               , "use16"+                               , "use32"+                               , "use64"+                               ])+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "append"+                               , "at"+                               , "break"+                               , "common"+                               , "display"+                               , "else"+                               , "end"+                               , "equ"+                               , "fix"+                               , "foward"+                               , "if"+                               , "irp"+                               , "irps"+                               , "label"+                               , "local"+                               , "macro"+                               , "match"+                               , "purge"+                               , "repeat"+                               , "rept"+                               , "restore"+                               , "reverse"+                               , "struc"+                               , "times"+                               , "virtual"+                               , "while"+                               ])+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Intel x86 (FASM)" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "\"'"+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Intel x86 (FASM)" , "String" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*[A-Za-z0-9@_.$?]+:"+                              , reCompiled = Just (compileRegex True "\\s*[A-Za-z0-9@_.$?]+:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(cmov|fcmov|j|loop|set)(a|ae|b|be|c|e|g|ge|l|le|na|nae|nb|nbe|nc|ne|ng|nge|nl|nle|no|np|ns|nz|o|p|pe|po|s|z)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(cmov|fcmov|j|loop|set)(a|ae|b|be|c|e|g|ge|l|le|na|nae|nb|nbe|nc|ne|ng|nge|nl|nle|no|np|ns|nz|o|p|pe|po|s|z)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(^|[ \\t,]+)((\\$|0x){1}[0-9]+[a-f0-9]*|[a-f0-9]+h)([ \\t,]+|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "(^|[ \\t,]+)((\\$|0x){1}[0-9]+[a-f0-9]*|[a-f0-9]+h)([ \\t,]+|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(^|[ \\t,]+)([0-7]+(q|o)|[01]+b)([ \\t,]+|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False "(^|[ \\t,]+)([0-7]+(q|o)|[01]+b)([ \\t,]+|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Preprocessor"+          , Context+              { cName = "Preprocessor"+              , cSyntax = "Intel x86 (FASM)"+              , cRules = []+              , cAttribute = PreprocessorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Intel x86 (FASM)"+              , cRules =+                  [ Rule+                      { rMatcher = AnyChar "\"'"+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "rCX (rCX12@yahoo.com)"+  , sVersion = "1"+  , sLicense = "GPL"+  , sExtensions = [ "*.asm" , "*.inc" , "*.fasm" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Fortran.hs view
@@ -0,0 +1,2205 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Fortran (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Fortran"+  , sFilename = "fortran.xml"+  , sShortname = "Fortran"+  , sContexts =+      fromList+        [ ( "default"+          , Context+              { cName = "default"+              , cSyntax = "Fortran"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Fortran" , "find_strings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Fortran" , "find_decls" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Fortran" , "find_intrinsics" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Fortran" , "find_io_stmnts" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Fortran" , "find_op_and_log" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Fortran" , "find_numbers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Fortran" , "find_preprocessor" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Fortran" , "find_comments" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Fortran" , "find_symbols" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Fortran" , "find_begin_stmnts" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Fortran" , "find_end_stmnts" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Fortran" , "find_mid_stmnts" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "end_of_string"+          , Context+              { cName = "end_of_string"+              , cSyntax = "Fortran"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&\\s*$"+                              , reCompiled = Just (compileRegex False "&\\s*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '&'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(!.*)?$"+                              , reCompiled = Just (compileRegex False "(!.*)?$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop , Pop ]+              , cDynamic = False+              }+          )+        , ( "find_begin_stmnts"+          , Context+              { cName = "find_begin_stmnts"+              , cSyntax = "Fortran"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bmodule\\s+procedure\\b"+                              , reCompiled =+                                  Just (compileRegex False "\\bmodule\\s+procedure\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(subroutine|function|block\\s*data)\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex False "\\b(subroutine|function|block\\s*data)\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(program|module|block\\s*data)\\b"+                              , reCompiled =+                                  Just (compileRegex False "\\b(program|module|block\\s*data)\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(then|do)\\b"+                              , reCompiled = Just (compileRegex False "\\b(then|do)\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_comments"+          , Context+              { cName = "find_comments"+              , cSyntax = "Fortran"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[cC\\*].*$"+                              , reCompiled = Just (compileRegex False "[cC\\*].*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "!.*$"+                              , reCompiled = Just (compileRegex False "!.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_decls"+          , Context+              { cName = "find_decls"+              , cSyntax = "Fortran"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\binteger[\\*]\\d{1,2}"+                              , reCompiled = Just (compileRegex False "\\binteger[\\*]\\d{1,2}")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\breal[\\*]\\d{1,2}"+                              , reCompiled = Just (compileRegex False "\\breal[\\*]\\d{1,2}")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bcomplex[\\*]\\d{1,2}"+                              , reCompiled = Just (compileRegex False "\\bcomplex[\\*]\\d{1,2}")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bend\\s*type\\b"+                              , reCompiled = Just (compileRegex False "\\bend\\s*type\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "allocatable"+                               , "double"+                               , "optional"+                               , "parameter"+                               , "pointer"+                               , "precision"+                               , "private"+                               , "public"+                               , "save"+                               , "sequence"+                               , "target"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*data\\b"+                              , reCompiled = Just (compileRegex False "\\s*data\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*real\\s*[(]"+                              , reCompiled = Just (compileRegex False "\\s*real\\s*[(]")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Fortran" , "find_paren" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*real(?![\\w\\*])"+                              , reCompiled = Just (compileRegex False "\\s*real(?![\\w\\*])")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bcharacter[*][0-9]+\\b"+                              , reCompiled = Just (compileRegex False "\\bcharacter[*][0-9]+\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b(type|integer|complex|character|logical|intent|dimension)\\b\\s*[(]"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "\\b(type|integer|complex|character|logical|intent|dimension)\\b\\s*[(]")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Fortran" , "find_paren" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b(type|integer|complex|character|logical|intent|dimension)\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "\\b(type|integer|complex|character|logical|intent|dimension)\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars ':' ':'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_end_stmnts"+          , Context+              { cName = "find_end_stmnts"+              , cSyntax = "Fortran"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bend\\s*(subroutine|function|block\\s*data)\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False "\\bend\\s*(subroutine|function|block\\s*data)\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bend\\s*(program|module)\\b"+                              , reCompiled =+                                  Just (compileRegex False "\\bend\\s*(program|module)\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bend\\s*(do|if)\\b"+                              , reCompiled = Just (compileRegex False "\\bend\\s*(do|if)\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bend\\s*(select|where|forall|interface)\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False "\\bend\\s*(select|where|forall|interface)\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\belse\\s*if\\b"+                              , reCompiled = Just (compileRegex False "\\belse\\s*if\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bend\\b"+                              , reCompiled = Just (compileRegex False "\\bend\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_intrinsics"+          , Context+              { cName = "find_intrinsics"+              , cSyntax = "Fortran"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "allocate"+                               , "assignment"+                               , "break"+                               , "call"+                               , "case"+                               , "common"+                               , "continue"+                               , "cycle"+                               , "deallocate"+                               , "default"+                               , "elemental"+                               , "elsewhere"+                               , "entry"+                               , "equivalence"+                               , "exit"+                               , "external"+                               , "for"+                               , "forall"+                               , "go"+                               , "goto"+                               , "if"+                               , "implicit"+                               , "include"+                               , "interface"+                               , "intrinsic"+                               , "namelist"+                               , "none"+                               , "nullify"+                               , "only"+                               , "operator"+                               , "pause"+                               , "procedure"+                               , "pure"+                               , "record"+                               , "recursive"+                               , "result"+                               , "return"+                               , "select"+                               , "selectcase"+                               , "stop"+                               , "to"+                               , "use"+                               , "where"+                               , "while"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "abs"+                               , "achar"+                               , "acos"+                               , "adjustl"+                               , "adjustr"+                               , "aimag"+                               , "aint"+                               , "alog"+                               , "alog10"+                               , "amax0"+                               , "amax1"+                               , "amin0"+                               , "amin1"+                               , "amod"+                               , "anint"+                               , "aprime"+                               , "asin"+                               , "atan"+                               , "atan2"+                               , "btest"+                               , "cabs"+                               , "ccos"+                               , "ceiling"+                               , "cexp"+                               , "char"+                               , "clog"+                               , "cmplx"+                               , "conjg"+                               , "cos"+                               , "cosh"+                               , "csin"+                               , "csqrt"+                               , "dabs"+                               , "dacos"+                               , "dasin"+                               , "datan"+                               , "datan2"+                               , "dble"+                               , "dcmplx"+                               , "dconjg"+                               , "dcos"+                               , "dcosh"+                               , "ddim"+                               , "ddmim"+                               , "dexp"+                               , "dfloat"+                               , "dim"+                               , "dimag"+                               , "dint"+                               , "dlog"+                               , "dlog10"+                               , "dmax1"+                               , "dmin1"+                               , "dmod"+                               , "dnint"+                               , "dprod"+                               , "dreal"+                               , "dsign"+                               , "dsin"+                               , "dsinh"+                               , "dsqrt"+                               , "dtan"+                               , "dtanh"+                               , "exp"+                               , "exponent"+                               , "float"+                               , "floor"+                               , "fraction"+                               , "iabs"+                               , "iachar"+                               , "iand"+                               , "ibclr"+                               , "ibits"+                               , "ibset"+                               , "ichar"+                               , "idim"+                               , "idint"+                               , "idnint"+                               , "ieor"+                               , "ifix"+                               , "index"+                               , "int"+                               , "ior"+                               , "ishft"+                               , "ishftc"+                               , "isign"+                               , "len_trim"+                               , "lge"+                               , "lgt"+                               , "lle"+                               , "llt"+                               , "log"+                               , "log10"+                               , "logical"+                               , "max"+                               , "max0"+                               , "max1"+                               , "merge"+                               , "min"+                               , "min0"+                               , "min1"+                               , "mod"+                               , "modulo"+                               , "mvbits"+                               , "nearest"+                               , "nint"+                               , "not"+                               , "rand"+                               , "real"+                               , "rrspacing"+                               , "scale"+                               , "scan"+                               , "set_exponent"+                               , "sign"+                               , "sin"+                               , "sinh"+                               , "sngl"+                               , "spacing"+                               , "sqrt"+                               , "tan"+                               , "tanh"+                               , "verify"+                               ])+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "allocated"+                               , "associated"+                               , "bit_size"+                               , "digits"+                               , "epsilon"+                               , "huge"+                               , "kind"+                               , "lbound"+                               , "len"+                               , "maxexponent"+                               , "minexponent"+                               , "precision"+                               , "present"+                               , "radix"+                               , "range"+                               , "shape"+                               , "size"+                               , "tiny"+                               , "ubound"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "all"+                               , "any"+                               , "count"+                               , "cshift"+                               , "dot_product"+                               , "eoshift"+                               , "matmul"+                               , "maxloc"+                               , "maxval"+                               , "minloc"+                               , "minval"+                               , "pack"+                               , "product"+                               , "repeat"+                               , "reshape"+                               , "selected_int_kind"+                               , "selected_real_kind"+                               , "spread"+                               , "sum"+                               , "transfer"+                               , "transpose"+                               , "trim"+                               , "unpack"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "date_and_time"+                               , "random_number"+                               , "random_seed"+                               , "system_clock"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_io_paren"+          , Context+              { cName = "find_io_paren"+              , cSyntax = "Fortran"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '*'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Fortran" , "inside_func_paren" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "advance"+                               , "end"+                               , "eor"+                               , "err"+                               , "fmt"+                               , "iostat"+                               , "size"+                               , "status"+                               , "unit"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "access"+                               , "action"+                               , "blank"+                               , "delim"+                               , "direct"+                               , "err"+                               , "exist"+                               , "file"+                               , "form"+                               , "formatted"+                               , "iostat"+                               , "name"+                               , "named"+                               , "nextrec"+                               , "number"+                               , "opened"+                               , "pad"+                               , "position"+                               , "read"+                               , "readwrite"+                               , "recl"+                               , "sequential"+                               , "unformatted"+                               , "unit"+                               , "write"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "access"+                               , "action"+                               , "blank"+                               , "delim"+                               , "err"+                               , "file"+                               , "form"+                               , "iostat"+                               , "pad"+                               , "position"+                               , "recl"+                               , "status"+                               , "unit"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Fortran" , "find_strings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Fortran" , "find_intrinsics" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Fortran" , "find_numbers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Fortran" , "find_symbols" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_io_stmnts"+          , Context+              { cName = "find_io_stmnts"+              , cSyntax = "Fortran"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b(read|write|backspace|rewind|end\\s*file|close)\\s*[(]"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "\\b(read|write|backspace|rewind|end\\s*file|close)\\s*[(]")+                              , reCaseSensitive = False+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Fortran" , "find_io_paren" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bopen\\s*[(]"+                              , reCompiled = Just (compileRegex False "\\bopen\\s*[(]")+                              , reCaseSensitive = False+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Fortran" , "find_io_paren" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\binquire\\s*[(]"+                              , reCompiled = Just (compileRegex False "\\binquire\\s*[(]")+                              , reCaseSensitive = False+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Fortran" , "find_io_paren" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bformat\\s*[(]"+                              , reCompiled = Just (compileRegex False "\\bformat\\s*[(]")+                              , reCaseSensitive = False+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Fortran" , "format_stmnt" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bend\\s*file\\b"+                              , reCompiled = Just (compileRegex False "\\bend\\s*file\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "access"+                               , "backspace"+                               , "close"+                               , "format"+                               , "inquire"+                               , "open"+                               , "print"+                               , "read"+                               , "rewind"+                               , "write"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_mid_stmnts"+          , Context+              { cName = "find_mid_stmnts"+              , cSyntax = "Fortran"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\belse\\b"+                              , reCompiled = Just (compileRegex False "\\belse\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bcontains\\b"+                              , reCompiled = Just (compileRegex False "\\bcontains\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_numbers"+          , Context+              { cName = "find_numbers"+              , cSyntax = "Fortran"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "[0-9]*\\.[0-9]+([de][+-]?[0-9]+)?([_]([0-9]+|[a-z][\\w_]*))?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "[0-9]*\\.[0-9]+([de][+-]?[0-9]+)?([_]([0-9]+|[a-z][\\w_]*))?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b[0-9]+\\.[0-9]*([de][+-]?[0-9]+)?([_]([0-9]+|[a-z][\\w_]*))?(?![a-z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "\\b[0-9]+\\.[0-9]*([de][+-]?[0-9]+)?([_]([0-9]+|[a-z][\\w_]*))?(?![a-z])")+                              , reCaseSensitive = False+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[0-9]+[de][+-]?[0-9]+([_]([0-9]+|[a-z][\\w_]*))?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False "\\b[0-9]+[de][+-]?[0-9]+([_]([0-9]+|[a-z][\\w_]*))?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[0-9]+([_]([0-9]+|[a-zA-Z][\\w_]*))?"+                              , reCompiled =+                                  Just+                                    (compileRegex False "\\b[0-9]+([_]([0-9]+|[a-zA-Z][\\w_]*))?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[bozx](['][0-9a-f]+[']|[\"][0-9a-f]+[\"])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False "\\b[bozx](['][0-9a-f]+[']|[\"][0-9a-f]+[\"])")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_op_and_log"+          , Context+              { cName = "find_op_and_log"+              , cSyntax = "Fortran"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.(true|false)\\."+                              , reCompiled = Just (compileRegex False "\\.(true|false)\\.")+                              , reCaseSensitive = False+                              }+                      , rAttribute = ConstantTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.[A-Za-z]+\\."+                              , reCompiled = Just (compileRegex False "\\.[A-Za-z]+\\.")+                              , reCaseSensitive = False+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(==|/=|<|<=|>|>=)"+                              , reCompiled = Just (compileRegex False "(==|/=|<|<=|>|>=)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_paren"+          , Context+              { cName = "find_paren"+              , cSyntax = "Fortran"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Fortran" , "find_paren" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_preprocessor"+          , Context+              { cName = "find_preprocessor"+              , cSyntax = "Fortran"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(#|cDEC\\$|CDEC\\$).*$"+                              , reCompiled = Just (compileRegex False "(#|cDEC\\$|CDEC\\$).*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_strings"+          , Context+              { cName = "find_strings"+              , cSyntax = "Fortran"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Fortran" , "string_1" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Fortran" , "string_2" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_symbols"+          , Context+              { cName = "find_symbols"+              , cSyntax = "Fortran"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '*'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '(' '/'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' ')'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "&+-*/=?[]^{|}~"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "(),"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "format_stmnt"+          , Context+              { cName = "format_stmnt"+              , cSyntax = "Fortran"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Fortran" , "format_stmnt" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[0-9]*/"+                              , reCompiled = Just (compileRegex False "[0-9]*/")+                              , reCaseSensitive = False+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar ":"+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Fortran" , "find_strings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Fortran" , "find_symbols" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "inside_func_paren"+          , Context+              { cName = "inside_func_paren"+              , cSyntax = "Fortran"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Fortran" , "inside_func_paren" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Fortran" , "find_strings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Fortran" , "find_intrinsics" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Fortran" , "find_numbers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "string_1"+          , Context+              { cName = "string_1"+              , cSyntax = "Fortran"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^']*'"+                              , reCompiled = Just (compileRegex False "[^']*'")+                              , reCaseSensitive = False+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&\\s*$"+                              , reCompiled = Just (compileRegex False "&\\s*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Fortran" , "end_of_string" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ".*(?=&\\s*$)"+                              , reCompiled = Just (compileRegex False ".*(?=&\\s*$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Fortran" , "end_of_string" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "string_2"+          , Context+              { cName = "string_2"+              , cSyntax = "Fortran"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^\"]*\""+                              , reCompiled = Just (compileRegex False "[^\"]*\"")+                              , reCaseSensitive = False+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&\\s*$"+                              , reCompiled = Just (compileRegex False "&\\s*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Fortran" , "end_of_string" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ".*(?=&\\s*$)"+                              , reCompiled = Just (compileRegex False ".*(?=&\\s*$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Fortran" , "end_of_string" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Franchin Matteo (fnch@libero.it)"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions =+      [ "*.f"+      , "*.F"+      , "*.for"+      , "*.FOR"+      , "*.f90"+      , "*.F90"+      , "*.fpp"+      , "*.FPP"+      , "*.f95"+      , "*.F95"+      ]+  , sStartingContext = "default"+  }
+ src/Skylighting/Syntax/Fsharp.hs view
@@ -0,0 +1,1254 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Fsharp (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "FSharp"+  , sFilename = "fsharp.xml"+  , sShortname = "Fsharp"+  , sContexts =+      fromList+        [ ( "Block"+          , Context+              { cName = "Block"+              , cSyntax = "FSharp"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "end" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "FSharp" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Camlp4 Quotation Constant"+          , Context+              { cName = "Camlp4 Quotation Constant"+              , cSyntax = "FSharp"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '>' '>'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '<' '<'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "FSharp" , "Camlp4 Quotation Constant" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "<:[A-Za-z\\300-\\326\\330-\\366\\370-\\377_][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*<"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "<:[A-Za-z\\300-\\326\\330-\\366\\370-\\377_][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*<")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "FSharp" , "Camlp4 Quotation Constant" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(\\\\|>>|<<)"+                              , reCompiled = Just (compileRegex True "\\\\(\\\\|>>|<<)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\<:[A-Za-z\\300-\\326\\330-\\366\\370-\\377_][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*<"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\<:[A-Za-z\\300-\\326\\330-\\366\\370-\\377_][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*<")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ModuleEnv"+          , Context+              { cName = "ModuleEnv"+              , cSyntax = "FSharp"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "[A-Z][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*\\s*\\."+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "[A-Z][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*\\s*\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "FSharp" , "ModuleEnv2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Z][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "[A-Z][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "ModuleEnv2"+          , Context+              { cName = "ModuleEnv2"+              , cSyntax = "FSharp"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Z][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "[A-Z][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "."+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Multiline Comment"+          , Context+              { cName = "Multiline Comment"+              , cSyntax = "FSharp"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' ')'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '(' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "FSharp" , "Multiline Comment" ) ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "FSharp"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '(' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "FSharp" , "Multiline Comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "FSharp" , "Singleline Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '[' '<'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '>' ']'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '[' '|'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '|' ']'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "do" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "done" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "module" , "open" ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "FSharp" , "ModuleEnv" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "begin" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "FSharp" , "Block" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "object" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "FSharp" , "Object" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "sig" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "FSharp" , "Sig" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "struct" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "FSharp" , "Struct" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "`\\s*[A-Za-z\\300-\\326\\330-\\366\\370-\\377_][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "`\\s*[A-Za-z\\300-\\326\\330-\\366\\370-\\377_][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "[A-Z][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*\\s*\\."+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "[A-Z][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*\\s*\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "FSharp" , "ModuleEnv2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Z][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "[A-Z][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "#[A-Za-z\\300-\\326\\330-\\366\\370-\\377_][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*.*$"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "#[A-Za-z\\300-\\326\\330-\\366\\370-\\377_][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "FSharp" , "String Constant" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "'((\\\\[ntbr'\"\\\\]|\\\\[0-9]{3}|\\\\x[0-9A-Fa-f]{2})|[^'])'"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "'((\\\\[ntbr'\"\\\\]|\\\\[0-9]{3}|\\\\x[0-9A-Fa-f]{2})|[^'])'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '<' '<'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "FSharp" , "Camlp4 Quotation Constant" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "<:[A-Za-z\\300-\\326\\330-\\366\\370-\\377_][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*<"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "<:[A-Za-z\\300-\\326\\330-\\366\\370-\\377_][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*<")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "FSharp" , "Camlp4 Quotation Constant" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "abstract"+                               , "and"+                               , "as"+                               , "assert"+                               , "base"+                               , "class"+                               , "delegate"+                               , "dowcast"+                               , "downto"+                               , "elif"+                               , "else"+                               , "exception"+                               , "extern"+                               , "false"+                               , "for"+                               , "fun"+                               , "function"+                               , "functor"+                               , "global"+                               , "if"+                               , "in"+                               , "inherit"+                               , "inline"+                               , "interfaece"+                               , "internal"+                               , "lazy"+                               , "let"+                               , "match"+                               , "member"+                               , "mutable"+                               , "namespace"+                               , "new"+                               , "not"+                               , "null"+                               , "of"+                               , "or"+                               , "override"+                               , "private"+                               , "public"+                               , "rec"+                               , "ref"+                               , "return"+                               , "static"+                               , "then"+                               , "to"+                               , "true"+                               , "try"+                               , "type"+                               , "upcast"+                               , "use"+                               , "val"+                               , "void"+                               , "when"+                               , "while"+                               , "with"+                               , "yield"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "bigint"+                               , "bool"+                               , "byte"+                               , "char"+                               , "decimal"+                               , "double"+                               , "float"+                               , "float32"+                               , "int"+                               , "int16"+                               , "int64"+                               , "nativeint"+                               , "option"+                               , "sbyte"+                               , "seq"+                               , "single"+                               , "string"+                               , "uint16"+                               , "uint32"+                               , "uint64"+                               , "unativeint"+                               , "unit"+                               , "void"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "[A-Za-z\\300-\\326\\330-\\366\\370-\\377_][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "[A-Za-z\\300-\\326\\330-\\366\\370-\\377_][A-Za-z\\300-\\326\\330-\\366\\370-\\3770-9_']*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-?0[xX][0-9A-Fa-f_]+"+                              , reCompiled = Just (compileRegex True "-?0[xX][0-9A-Fa-f_]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-?0[oO][0-7_]+"+                              , reCompiled = Just (compileRegex True "-?0[oO][0-7_]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-?0[bB][01_]+"+                              , reCompiled = Just (compileRegex True "-?0[bB][01_]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "-?[0-9][0-9_]*((\\.([0-9][0-9_]*)?([eE][-+]?[0-9][0-9_]*)?)|([eE][-+]?[0-9][0-9_]*))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "-?[0-9][0-9_]*((\\.([0-9][0-9_]*)?([eE][-+]?[0-9][0-9_]*)?)|([eE][-+]?[0-9][0-9_]*))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-?[0-9][0-9_]*"+                              , reCompiled = Just (compileRegex True "-?[0-9][0-9_]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Object"+          , Context+              { cName = "Object"+              , cSyntax = "FSharp"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "end" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "FSharp" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Sig"+          , Context+              { cName = "Sig"+              , cSyntax = "FSharp"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "end" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "FSharp" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Singleline Comment"+          , Context+              { cName = "Singleline Comment"+              , cSyntax = "FSharp"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String Constant"+          , Context+              { cName = "String Constant"+              , cSyntax = "FSharp"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\\\[ntbr'\"\\\\]|\\\\[0-9]{3}|\\\\x[0-9A-Fa-f]{2})"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(\\\\[ntbr'\"\\\\]|\\\\[0-9]{3}|\\\\x[0-9A-Fa-f]{2})")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\$"+                              , reCompiled = Just (compileRegex True "\\\\$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Struct"+          , Context+              { cName = "Struct"+              , cSyntax = "FSharp"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "end" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "FSharp" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Bas Bossink (bas.bossink@gmail.com)"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions = [ "*.fs" , "*.fsi" , "*.fsx" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Gcc.hs view
@@ -0,0 +1,1207 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Gcc (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "GCCExtensions"+  , sFilename = "gcc.xml"+  , sShortname = "Gcc"+  , sContexts =+      fromList+        [ ( "AttrArgs"+          , Context+              { cName = "AttrArgs"+              , cSyntax = "GCCExtensions"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '(' '('+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars ')' ')'+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "GCCExtensions" , "Close" ) ]+                      }+                  ]+              , cAttribute = ExtensionTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "AttrStringArg"+          , Context+              { cName = "AttrStringArg"+              , cSyntax = "GCCExtensions"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Close"+          , Context+              { cName = "Close"+              , cSyntax = "GCCExtensions"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "GCCExtensions" , "AttrStringArg" ) ]+                      }+                  ]+              , cAttribute = ExtensionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DetectGccExtensions"+          , Context+              { cName = "DetectGccExtensions"+              , cSyntax = "GCCExtensions"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "_FORTIFY_SOURCE"+                               , "_GNU_SOURCE"+                               , "_ILP32"+                               , "_LP64"+                               , "_REENTRANT"+                               , "_STDC_PREDEF_H"+                               , "__3dNOW_A__"+                               , "__3dNOW__"+                               , "__ABM__"+                               , "__ADX__"+                               , "__AES__"+                               , "__ATOMIC_ACQUIRE"+                               , "__ATOMIC_ACQ_REL"+                               , "__ATOMIC_CONSUME"+                               , "__ATOMIC_HLE_ACQUIRE"+                               , "__ATOMIC_HLE_RELEASE"+                               , "__ATOMIC_RELAXED"+                               , "__ATOMIC_RELEASE"+                               , "__ATOMIC_SEQ_CST"+                               , "__AVX2__"+                               , "__AVX__"+                               , "__BASE_FILE__"+                               , "__BIGGEST_ALIGNMENT__"+                               , "__BMI2__"+                               , "__BMI__"+                               , "__BYTE_ORDER__"+                               , "__CHAR16_TYPE__"+                               , "__CHAR32_TYPE__"+                               , "__CHAR_BIT__"+                               , "__CHAR_UNSIGNED__"+                               , "__COUNTER__"+                               , "__DBL_DECIMAL_DIG__"+                               , "__DBL_DENORM_MIN__"+                               , "__DBL_DIG__"+                               , "__DBL_EPSILON__"+                               , "__DBL_HAS_DENORM__"+                               , "__DBL_HAS_INFINITY__"+                               , "__DBL_HAS_QUIET_NAN__"+                               , "__DBL_MANT_DIG__"+                               , "__DBL_MAX_10_EXP__"+                               , "__DBL_MAX_EXP__"+                               , "__DBL_MAX__"+                               , "__DBL_MIN_10_EXP__"+                               , "__DBL_MIN_EXP__"+                               , "__DBL_MIN__"+                               , "__DEC128_EPSILON__"+                               , "__DEC128_MANT_DIG__"+                               , "__DEC128_MAX_EXP__"+                               , "__DEC128_MAX__"+                               , "__DEC128_MIN_EXP__"+                               , "__DEC128_MIN__"+                               , "__DEC128_SUBNORMAL_MIN__"+                               , "__DEC32_EPSILON__"+                               , "__DEC32_MANT_DIG__"+                               , "__DEC32_MAX_EXP__"+                               , "__DEC32_MAX__"+                               , "__DEC32_MIN_EXP__"+                               , "__DEC32_MIN__"+                               , "__DEC32_SUBNORMAL_MIN__"+                               , "__DEC64_EPSILON__"+                               , "__DEC64_MANT_DIG__"+                               , "__DEC64_MAX_EXP__"+                               , "__DEC64_MAX__"+                               , "__DEC64_MIN_EXP__"+                               , "__DEC64_MIN__"+                               , "__DEC64_SUBNORMAL_MIN__"+                               , "__DECIMAL_BID_FORMAT__"+                               , "__DECIMAL_DIG__"+                               , "__DEC_EVAL_METHOD__"+                               , "__DEPRECATED"+                               , "__ELF__"+                               , "__EXCEPTIONS"+                               , "__F16C__"+                               , "__FAST_MATH__"+                               , "__FINITE_MATH_ONLY__"+                               , "__FLOAT_WORD_ORDER__"+                               , "__FLT_DECIMAL_DIG__"+                               , "__FLT_DENORM_MIN__"+                               , "__FLT_DIG__"+                               , "__FLT_EPSILON__"+                               , "__FLT_EVAL_METHOD__"+                               , "__FLT_HAS_DENORM__"+                               , "__FLT_HAS_INFINITY__"+                               , "__FLT_HAS_QUIET_NAN__"+                               , "__FLT_MANT_DIG__"+                               , "__FLT_MAX_10_EXP__"+                               , "__FLT_MAX_EXP__"+                               , "__FLT_MAX__"+                               , "__FLT_MIN_10_EXP__"+                               , "__FLT_MIN_EXP__"+                               , "__FLT_MIN__"+                               , "__FLT_RADIX__"+                               , "__FMA4__"+                               , "__FMA__"+                               , "__FP_FAST_FMA"+                               , "__FP_FAST_FMAF"+                               , "__FSGSBASE__"+                               , "__FUNCTION__"+                               , "__FXSR__"+                               , "__GCC_ATOMIC_BOOL_LOCK_FREE"+                               , "__GCC_ATOMIC_CHAR16_T_LOCK_FREE"+                               , "__GCC_ATOMIC_CHAR32_T_LOCK_FREE"+                               , "__GCC_ATOMIC_CHAR_LOCK_FREE"+                               , "__GCC_ATOMIC_INT_LOCK_FREE"+                               , "__GCC_ATOMIC_LLONG_LOCK_FREE"+                               , "__GCC_ATOMIC_LONG_LOCK_FREE"+                               , "__GCC_ATOMIC_POINTER_LOCK_FREE"+                               , "__GCC_ATOMIC_SHORT_LOCK_FREE"+                               , "__GCC_ATOMIC_TEST_AND_SET_TRUEVAL"+                               , "__GCC_ATOMIC_WCHAR_T_LOCK_FREE"+                               , "__GCC_HAVE_DWARF2_CFI_ASM"+                               , "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1"+                               , "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16"+                               , "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2"+                               , "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4"+                               , "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8"+                               , "__GFORTRAN__"+                               , "__GNUC_GNU_INLINE__"+                               , "__GNUC_MINOR__"+                               , "__GNUC_PATCHLEVEL__"+                               , "__GNUC_STDC_INLINE__"+                               , "__GNUC__"+                               , "__GNUG__"+                               , "__GXX_ABI_VERSION"+                               , "__GXX_EXPERIMENTAL_CXX0X__"+                               , "__GXX_RTTI"+                               , "__GXX_WEAK__"+                               , "__ILP32__"+                               , "__INCLUDE_LEVEL__"+                               , "__INT16_C"+                               , "__INT16_MAX__"+                               , "__INT16_TYPE__"+                               , "__INT32_C"+                               , "__INT32_MAX__"+                               , "__INT32_TYPE__"+                               , "__INT64_C"+                               , "__INT64_MAX__"+                               , "__INT64_TYPE__"+                               , "__INT8_C"+                               , "__INT8_MAX__"+                               , "__INT8_TYPE__"+                               , "__INTMAX_C"+                               , "__INTMAX_MAX__"+                               , "__INTMAX_TYPE__"+                               , "__INTPTR_MAX__"+                               , "__INTPTR_TYPE__"+                               , "__INT_FAST16_MAX__"+                               , "__INT_FAST16_TYPE__"+                               , "__INT_FAST32_MAX__"+                               , "__INT_FAST32_TYPE__"+                               , "__INT_FAST64_MAX__"+                               , "__INT_FAST64_TYPE__"+                               , "__INT_FAST8_MAX__"+                               , "__INT_FAST8_TYPE__"+                               , "__INT_LEAST16_MAX__"+                               , "__INT_LEAST16_TYPE__"+                               , "__INT_LEAST32_MAX__"+                               , "__INT_LEAST32_TYPE__"+                               , "__INT_LEAST64_MAX__"+                               , "__INT_LEAST64_TYPE__"+                               , "__INT_LEAST8_MAX__"+                               , "__INT_LEAST8_TYPE__"+                               , "__INT_MAX__"+                               , "__LDBL_DENORM_MIN__"+                               , "__LDBL_DIG__"+                               , "__LDBL_EPSILON__"+                               , "__LDBL_HAS_DENORM__"+                               , "__LDBL_HAS_INFINITY__"+                               , "__LDBL_HAS_QUIET_NAN__"+                               , "__LDBL_MANT_DIG__"+                               , "__LDBL_MAX_10_EXP__"+                               , "__LDBL_MAX_EXP__"+                               , "__LDBL_MAX__"+                               , "__LDBL_MIN_10_EXP__"+                               , "__LDBL_MIN_EXP__"+                               , "__LDBL_MIN__"+                               , "__LONG_LONG_MAX__"+                               , "__LONG_MAX__"+                               , "__LP64__"+                               , "__LWP__"+                               , "__LZCNT__"+                               , "__MMX__"+                               , "__NEXT_RUNTIME__"+                               , "__NO_INLINE__"+                               , "__OPTIMIZE_SIZE__"+                               , "__OPTIMIZE__"+                               , "__ORDER_BIG_ENDIAN__"+                               , "__ORDER_LITTLE_ENDIAN__"+                               , "__ORDER_PDP_ENDIAN__"+                               , "__PCLMUL__"+                               , "__PIC__"+                               , "__PIE__"+                               , "__POPCNT__"+                               , "__PRAGMA_REDEFINE_EXTNAME"+                               , "__PRETTY_FUNCTION__"+                               , "__PRFCHW__"+                               , "__PTRDIFF_MAX__"+                               , "__PTRDIFF_TYPE__"+                               , "__RDRND__"+                               , "__RDSEED__"+                               , "__REGISTER_PREFIX__"+                               , "__RTM__"+                               , "__SANITIZE_ADDRESS__"+                               , "__SCHAR_MAX__"+                               , "__SHRT_MAX__"+                               , "__SIG_ATOMIC_MAX__"+                               , "__SIG_ATOMIC_MIN__"+                               , "__SIG_ATOMIC_TYPE__"+                               , "__SIZEOF_DOUBLE__"+                               , "__SIZEOF_FLOAT__"+                               , "__SIZEOF_INT128__"+                               , "__SIZEOF_INT__"+                               , "__SIZEOF_LONG_DOUBLE__"+                               , "__SIZEOF_LONG_LONG__"+                               , "__SIZEOF_LONG__"+                               , "__SIZEOF_POINTER__"+                               , "__SIZEOF_PTRDIFF_T__"+                               , "__SIZEOF_SHORT__"+                               , "__SIZEOF_SIZE_T__"+                               , "__SIZEOF_WCHAR_T__"+                               , "__SIZEOF_WINT_T__"+                               , "__SIZE_MAX__"+                               , "__SIZE_TYPE__"+                               , "__SSE2_MATH__"+                               , "__SSE2__"+                               , "__SSE3__"+                               , "__SSE4A__"+                               , "__SSE4_1__"+                               , "__SSE4_2__"+                               , "__SSE_MATH__"+                               , "__SSE__"+                               , "__SSP_ALL__"+                               , "__SSP__"+                               , "__SSSE3__"+                               , "__STDC_HOSTED__"+                               , "__STDC_IEC_559_COMPLEX__"+                               , "__STDC_IEC_559__"+                               , "__STDC_ISO_10646__"+                               , "__STDC_NO_THREADS__"+                               , "__STDC_UTF_16__"+                               , "__STDC_UTF_32__"+                               , "__STDC_VERSION__"+                               , "__STDC__"+                               , "__STRICT_ANSI__"+                               , "__TBM__"+                               , "__TIMESTAMP__"+                               , "__UINT16_C"+                               , "__UINT16_MAX__"+                               , "__UINT16_TYPE__"+                               , "__UINT32_C"+                               , "__UINT32_MAX__"+                               , "__UINT32_TYPE__"+                               , "__UINT64_C"+                               , "__UINT64_MAX__"+                               , "__UINT64_TYPE__"+                               , "__UINT8_C"+                               , "__UINT8_MAX__"+                               , "__UINT8_TYPE__"+                               , "__UINTMAX_C"+                               , "__UINTMAX_MAX__"+                               , "__UINTMAX_TYPE__"+                               , "__UINTPTR_MAX__"+                               , "__UINTPTR_TYPE__"+                               , "__UINT_FAST16_MAX__"+                               , "__UINT_FAST16_TYPE__"+                               , "__UINT_FAST32_MAX__"+                               , "__UINT_FAST32_TYPE__"+                               , "__UINT_FAST64_MAX__"+                               , "__UINT_FAST64_TYPE__"+                               , "__UINT_FAST8_MAX__"+                               , "__UINT_FAST8_TYPE__"+                               , "__UINT_LEAST16_MAX__"+                               , "__UINT_LEAST16_TYPE__"+                               , "__UINT_LEAST32_MAX__"+                               , "__UINT_LEAST32_TYPE__"+                               , "__UINT_LEAST64_MAX__"+                               , "__UINT_LEAST64_TYPE__"+                               , "__UINT_LEAST8_MAX__"+                               , "__UINT_LEAST8_TYPE__"+                               , "__USER_LABEL_PREFIX__"+                               , "__USING_SJLJ_EXCEPTIONS__"+                               , "__VA_ARGS__"+                               , "__VERSION__"+                               , "__WCHAR_MAX__"+                               , "__WCHAR_MIN__"+                               , "__WCHAR_TYPE__"+                               , "__WCHAR_UNSIGNED__"+                               , "__WINT_MAX__"+                               , "__WINT_MIN__"+                               , "__WINT_TYPE__"+                               , "__XOP__"+                               , "__XSAVEOPT__"+                               , "__XSAVE__"+                               , "__amd64"+                               , "__amd64__"+                               , "__amdfam10"+                               , "__amdfam10__"+                               , "__athlon"+                               , "__athlon__"+                               , "__athlon_sse__"+                               , "__atom"+                               , "__atom__"+                               , "__bdver1"+                               , "__bdver1__"+                               , "__bdver2"+                               , "__bdver2__"+                               , "__bdver3"+                               , "__bdver3__"+                               , "__btver1"+                               , "__btver1__"+                               , "__btver2"+                               , "__btver2__"+                               , "__code_model_32__"+                               , "__code_model_small__"+                               , "__core2"+                               , "__core2__"+                               , "__core_avx2"+                               , "__core_avx2__"+                               , "__corei7"+                               , "__corei7__"+                               , "__cplusplus"+                               , "__geode"+                               , "__geode__"+                               , "__gnu_linux__"+                               , "__i386"+                               , "__i386__"+                               , "__i486"+                               , "__i486__"+                               , "__i586"+                               , "__i586__"+                               , "__i686"+                               , "__i686__"+                               , "__k6"+                               , "__k6_2__"+                               , "__k6_3__"+                               , "__k6__"+                               , "__k8"+                               , "__k8__"+                               , "__linux"+                               , "__linux__"+                               , "__nocona"+                               , "__nocona__"+                               , "__pentium"+                               , "__pentium4"+                               , "__pentium4__"+                               , "__pentium__"+                               , "__pentium_mmx__"+                               , "__pentiumpro"+                               , "__pentiumpro__"+                               , "__pic__"+                               , "__pie__"+                               , "__tune_amdfam10__"+                               , "__tune_athlon__"+                               , "__tune_athlon_sse__"+                               , "__tune_atom__"+                               , "__tune_bdver1__"+                               , "__tune_bdver2__"+                               , "__tune_bdver3__"+                               , "__tune_btver1__"+                               , "__tune_btver2__"+                               , "__tune_core2__"+                               , "__tune_core_avx2__"+                               , "__tune_corei7__"+                               , "__tune_geode__"+                               , "__tune_i386__"+                               , "__tune_i486__"+                               , "__tune_i586__"+                               , "__tune_i686__"+                               , "__tune_k6_2__"+                               , "__tune_k6_3__"+                               , "__tune_k6__"+                               , "__tune_k8__"+                               , "__tune_nocona__"+                               , "__tune_pentium2__"+                               , "__tune_pentium3__"+                               , "__tune_pentium4__"+                               , "__tune_pentium__"+                               , "__tune_pentium_mmx__"+                               , "__tune_pentiumpro__"+                               , "__unix"+                               , "__unix__"+                               , "__x86_64"+                               , "__x86_64__"+                               , "i386"+                               , "linux"+                               , "unix"+                               ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "__atomic_add_fetch"+                               , "__atomic_always_lock_free"+                               , "__atomic_and_fetch"+                               , "__atomic_clear"+                               , "__atomic_compare_exchange"+                               , "__atomic_compare_exchange_n"+                               , "__atomic_exchange"+                               , "__atomic_exchange_n"+                               , "__atomic_fetch_add"+                               , "__atomic_fetch_and"+                               , "__atomic_fetch_nand"+                               , "__atomic_fetch_or"+                               , "__atomic_fetch_sub"+                               , "__atomic_fetch_xor"+                               , "__atomic_is_lock_free"+                               , "__atomic_load"+                               , "__atomic_load_n"+                               , "__atomic_nand_fetch"+                               , "__atomic_or_fetch"+                               , "__atomic_signal_fence"+                               , "__atomic_store"+                               , "__atomic_store_n"+                               , "__atomic_sub_fetch"+                               , "__atomic_test_and_set"+                               , "__atomic_thread_fence"+                               , "__atomic_xor_fetch"+                               , "__has_nothrow_assign"+                               , "__has_nothrow_constructor"+                               , "__has_nothrow_copy"+                               , "__has_trivial_assign"+                               , "__has_trivial_constructor"+                               , "__has_trivial_copy"+                               , "__has_trivial_destructor"+                               , "__has_virtual_destructor"+                               , "__is_abstract"+                               , "__is_base_of"+                               , "__is_class"+                               , "__is_empty"+                               , "__is_enum"+                               , "__is_pod"+                               , "__is_polymorphic"+                               , "__is_union"+                               , "__sync_add_and_fetch"+                               , "__sync_and_and_fetch"+                               , "__sync_bool_compare_and_swap"+                               , "__sync_fetch_and_add"+                               , "__sync_fetch_and_and"+                               , "__sync_fetch_and_nand"+                               , "__sync_fetch_and_or"+                               , "__sync_fetch_and_sub"+                               , "__sync_fetch_and_xor"+                               , "__sync_lock_release"+                               , "__sync_lock_test_and_set"+                               , "__sync_nand_and_fetch"+                               , "__sync_or_and_fetch"+                               , "__sync_sub_and_fetch"+                               , "__sync_synchronize"+                               , "__sync_val_compare_and_swap"+                               , "__sync_xor_and_fetch"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "_Accum"+                               , "_Decimal128"+                               , "_Decimal32"+                               , "_Decimal64"+                               , "_Fract"+                               , "_Sat"+                               , "__float128"+                               , "__float80"+                               , "__fp16"+                               , "__int128"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "__attribute__"+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "GCCExtensions" , "AttrArgs" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "__declspec"+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "GCCExtensions" , "AttrArgs" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "__alignof__"+                               , "__asm__"+                               , "__complex__"+                               , "__const__"+                               , "__extension__"+                               , "__imag__"+                               , "__inline__"+                               , "__label__"+                               , "__real__"+                               , "__restrict"+                               , "__restrict__"+                               , "__thread"+                               , "__typeof__"+                               , "typeof"+                               ])+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "__builtin_[a-zA-Z0-9_]+"+                              , reCompiled = Just (compileRegex True "__builtin_[a-zA-Z0-9_]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "0[Bb][01]+([Uu][Ll]{0,2}|[Ll]{0,2}[Uu]?|_[_0-9A-Za-z]*)?\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "0[Bb][01]+([Uu][Ll]{0,2}|[Ll]{0,2}[Uu]?|_[_0-9A-Za-z]*)?\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "GNUMacros"+          , Context+              { cName = "GNUMacros"+              , cSyntax = "GCCExtensions"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "_FORTIFY_SOURCE"+                               , "_GNU_SOURCE"+                               , "_ILP32"+                               , "_LP64"+                               , "_REENTRANT"+                               , "_STDC_PREDEF_H"+                               , "__3dNOW_A__"+                               , "__3dNOW__"+                               , "__ABM__"+                               , "__ADX__"+                               , "__AES__"+                               , "__ATOMIC_ACQUIRE"+                               , "__ATOMIC_ACQ_REL"+                               , "__ATOMIC_CONSUME"+                               , "__ATOMIC_HLE_ACQUIRE"+                               , "__ATOMIC_HLE_RELEASE"+                               , "__ATOMIC_RELAXED"+                               , "__ATOMIC_RELEASE"+                               , "__ATOMIC_SEQ_CST"+                               , "__AVX2__"+                               , "__AVX__"+                               , "__BASE_FILE__"+                               , "__BIGGEST_ALIGNMENT__"+                               , "__BMI2__"+                               , "__BMI__"+                               , "__BYTE_ORDER__"+                               , "__CHAR16_TYPE__"+                               , "__CHAR32_TYPE__"+                               , "__CHAR_BIT__"+                               , "__CHAR_UNSIGNED__"+                               , "__COUNTER__"+                               , "__DBL_DECIMAL_DIG__"+                               , "__DBL_DENORM_MIN__"+                               , "__DBL_DIG__"+                               , "__DBL_EPSILON__"+                               , "__DBL_HAS_DENORM__"+                               , "__DBL_HAS_INFINITY__"+                               , "__DBL_HAS_QUIET_NAN__"+                               , "__DBL_MANT_DIG__"+                               , "__DBL_MAX_10_EXP__"+                               , "__DBL_MAX_EXP__"+                               , "__DBL_MAX__"+                               , "__DBL_MIN_10_EXP__"+                               , "__DBL_MIN_EXP__"+                               , "__DBL_MIN__"+                               , "__DEC128_EPSILON__"+                               , "__DEC128_MANT_DIG__"+                               , "__DEC128_MAX_EXP__"+                               , "__DEC128_MAX__"+                               , "__DEC128_MIN_EXP__"+                               , "__DEC128_MIN__"+                               , "__DEC128_SUBNORMAL_MIN__"+                               , "__DEC32_EPSILON__"+                               , "__DEC32_MANT_DIG__"+                               , "__DEC32_MAX_EXP__"+                               , "__DEC32_MAX__"+                               , "__DEC32_MIN_EXP__"+                               , "__DEC32_MIN__"+                               , "__DEC32_SUBNORMAL_MIN__"+                               , "__DEC64_EPSILON__"+                               , "__DEC64_MANT_DIG__"+                               , "__DEC64_MAX_EXP__"+                               , "__DEC64_MAX__"+                               , "__DEC64_MIN_EXP__"+                               , "__DEC64_MIN__"+                               , "__DEC64_SUBNORMAL_MIN__"+                               , "__DECIMAL_BID_FORMAT__"+                               , "__DECIMAL_DIG__"+                               , "__DEC_EVAL_METHOD__"+                               , "__DEPRECATED"+                               , "__ELF__"+                               , "__EXCEPTIONS"+                               , "__F16C__"+                               , "__FAST_MATH__"+                               , "__FINITE_MATH_ONLY__"+                               , "__FLOAT_WORD_ORDER__"+                               , "__FLT_DECIMAL_DIG__"+                               , "__FLT_DENORM_MIN__"+                               , "__FLT_DIG__"+                               , "__FLT_EPSILON__"+                               , "__FLT_EVAL_METHOD__"+                               , "__FLT_HAS_DENORM__"+                               , "__FLT_HAS_INFINITY__"+                               , "__FLT_HAS_QUIET_NAN__"+                               , "__FLT_MANT_DIG__"+                               , "__FLT_MAX_10_EXP__"+                               , "__FLT_MAX_EXP__"+                               , "__FLT_MAX__"+                               , "__FLT_MIN_10_EXP__"+                               , "__FLT_MIN_EXP__"+                               , "__FLT_MIN__"+                               , "__FLT_RADIX__"+                               , "__FMA4__"+                               , "__FMA__"+                               , "__FP_FAST_FMA"+                               , "__FP_FAST_FMAF"+                               , "__FSGSBASE__"+                               , "__FUNCTION__"+                               , "__FXSR__"+                               , "__GCC_ATOMIC_BOOL_LOCK_FREE"+                               , "__GCC_ATOMIC_CHAR16_T_LOCK_FREE"+                               , "__GCC_ATOMIC_CHAR32_T_LOCK_FREE"+                               , "__GCC_ATOMIC_CHAR_LOCK_FREE"+                               , "__GCC_ATOMIC_INT_LOCK_FREE"+                               , "__GCC_ATOMIC_LLONG_LOCK_FREE"+                               , "__GCC_ATOMIC_LONG_LOCK_FREE"+                               , "__GCC_ATOMIC_POINTER_LOCK_FREE"+                               , "__GCC_ATOMIC_SHORT_LOCK_FREE"+                               , "__GCC_ATOMIC_TEST_AND_SET_TRUEVAL"+                               , "__GCC_ATOMIC_WCHAR_T_LOCK_FREE"+                               , "__GCC_HAVE_DWARF2_CFI_ASM"+                               , "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1"+                               , "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16"+                               , "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2"+                               , "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4"+                               , "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8"+                               , "__GFORTRAN__"+                               , "__GNUC_GNU_INLINE__"+                               , "__GNUC_MINOR__"+                               , "__GNUC_PATCHLEVEL__"+                               , "__GNUC_STDC_INLINE__"+                               , "__GNUC__"+                               , "__GNUG__"+                               , "__GXX_ABI_VERSION"+                               , "__GXX_EXPERIMENTAL_CXX0X__"+                               , "__GXX_RTTI"+                               , "__GXX_WEAK__"+                               , "__ILP32__"+                               , "__INCLUDE_LEVEL__"+                               , "__INT16_C"+                               , "__INT16_MAX__"+                               , "__INT16_TYPE__"+                               , "__INT32_C"+                               , "__INT32_MAX__"+                               , "__INT32_TYPE__"+                               , "__INT64_C"+                               , "__INT64_MAX__"+                               , "__INT64_TYPE__"+                               , "__INT8_C"+                               , "__INT8_MAX__"+                               , "__INT8_TYPE__"+                               , "__INTMAX_C"+                               , "__INTMAX_MAX__"+                               , "__INTMAX_TYPE__"+                               , "__INTPTR_MAX__"+                               , "__INTPTR_TYPE__"+                               , "__INT_FAST16_MAX__"+                               , "__INT_FAST16_TYPE__"+                               , "__INT_FAST32_MAX__"+                               , "__INT_FAST32_TYPE__"+                               , "__INT_FAST64_MAX__"+                               , "__INT_FAST64_TYPE__"+                               , "__INT_FAST8_MAX__"+                               , "__INT_FAST8_TYPE__"+                               , "__INT_LEAST16_MAX__"+                               , "__INT_LEAST16_TYPE__"+                               , "__INT_LEAST32_MAX__"+                               , "__INT_LEAST32_TYPE__"+                               , "__INT_LEAST64_MAX__"+                               , "__INT_LEAST64_TYPE__"+                               , "__INT_LEAST8_MAX__"+                               , "__INT_LEAST8_TYPE__"+                               , "__INT_MAX__"+                               , "__LDBL_DENORM_MIN__"+                               , "__LDBL_DIG__"+                               , "__LDBL_EPSILON__"+                               , "__LDBL_HAS_DENORM__"+                               , "__LDBL_HAS_INFINITY__"+                               , "__LDBL_HAS_QUIET_NAN__"+                               , "__LDBL_MANT_DIG__"+                               , "__LDBL_MAX_10_EXP__"+                               , "__LDBL_MAX_EXP__"+                               , "__LDBL_MAX__"+                               , "__LDBL_MIN_10_EXP__"+                               , "__LDBL_MIN_EXP__"+                               , "__LDBL_MIN__"+                               , "__LONG_LONG_MAX__"+                               , "__LONG_MAX__"+                               , "__LP64__"+                               , "__LWP__"+                               , "__LZCNT__"+                               , "__MMX__"+                               , "__NEXT_RUNTIME__"+                               , "__NO_INLINE__"+                               , "__OPTIMIZE_SIZE__"+                               , "__OPTIMIZE__"+                               , "__ORDER_BIG_ENDIAN__"+                               , "__ORDER_LITTLE_ENDIAN__"+                               , "__ORDER_PDP_ENDIAN__"+                               , "__PCLMUL__"+                               , "__PIC__"+                               , "__PIE__"+                               , "__POPCNT__"+                               , "__PRAGMA_REDEFINE_EXTNAME"+                               , "__PRETTY_FUNCTION__"+                               , "__PRFCHW__"+                               , "__PTRDIFF_MAX__"+                               , "__PTRDIFF_TYPE__"+                               , "__RDRND__"+                               , "__RDSEED__"+                               , "__REGISTER_PREFIX__"+                               , "__RTM__"+                               , "__SANITIZE_ADDRESS__"+                               , "__SCHAR_MAX__"+                               , "__SHRT_MAX__"+                               , "__SIG_ATOMIC_MAX__"+                               , "__SIG_ATOMIC_MIN__"+                               , "__SIG_ATOMIC_TYPE__"+                               , "__SIZEOF_DOUBLE__"+                               , "__SIZEOF_FLOAT__"+                               , "__SIZEOF_INT128__"+                               , "__SIZEOF_INT__"+                               , "__SIZEOF_LONG_DOUBLE__"+                               , "__SIZEOF_LONG_LONG__"+                               , "__SIZEOF_LONG__"+                               , "__SIZEOF_POINTER__"+                               , "__SIZEOF_PTRDIFF_T__"+                               , "__SIZEOF_SHORT__"+                               , "__SIZEOF_SIZE_T__"+                               , "__SIZEOF_WCHAR_T__"+                               , "__SIZEOF_WINT_T__"+                               , "__SIZE_MAX__"+                               , "__SIZE_TYPE__"+                               , "__SSE2_MATH__"+                               , "__SSE2__"+                               , "__SSE3__"+                               , "__SSE4A__"+                               , "__SSE4_1__"+                               , "__SSE4_2__"+                               , "__SSE_MATH__"+                               , "__SSE__"+                               , "__SSP_ALL__"+                               , "__SSP__"+                               , "__SSSE3__"+                               , "__STDC_HOSTED__"+                               , "__STDC_IEC_559_COMPLEX__"+                               , "__STDC_IEC_559__"+                               , "__STDC_ISO_10646__"+                               , "__STDC_NO_THREADS__"+                               , "__STDC_UTF_16__"+                               , "__STDC_UTF_32__"+                               , "__STDC_VERSION__"+                               , "__STDC__"+                               , "__STRICT_ANSI__"+                               , "__TBM__"+                               , "__TIMESTAMP__"+                               , "__UINT16_C"+                               , "__UINT16_MAX__"+                               , "__UINT16_TYPE__"+                               , "__UINT32_C"+                               , "__UINT32_MAX__"+                               , "__UINT32_TYPE__"+                               , "__UINT64_C"+                               , "__UINT64_MAX__"+                               , "__UINT64_TYPE__"+                               , "__UINT8_C"+                               , "__UINT8_MAX__"+                               , "__UINT8_TYPE__"+                               , "__UINTMAX_C"+                               , "__UINTMAX_MAX__"+                               , "__UINTMAX_TYPE__"+                               , "__UINTPTR_MAX__"+                               , "__UINTPTR_TYPE__"+                               , "__UINT_FAST16_MAX__"+                               , "__UINT_FAST16_TYPE__"+                               , "__UINT_FAST32_MAX__"+                               , "__UINT_FAST32_TYPE__"+                               , "__UINT_FAST64_MAX__"+                               , "__UINT_FAST64_TYPE__"+                               , "__UINT_FAST8_MAX__"+                               , "__UINT_FAST8_TYPE__"+                               , "__UINT_LEAST16_MAX__"+                               , "__UINT_LEAST16_TYPE__"+                               , "__UINT_LEAST32_MAX__"+                               , "__UINT_LEAST32_TYPE__"+                               , "__UINT_LEAST64_MAX__"+                               , "__UINT_LEAST64_TYPE__"+                               , "__UINT_LEAST8_MAX__"+                               , "__UINT_LEAST8_TYPE__"+                               , "__USER_LABEL_PREFIX__"+                               , "__USING_SJLJ_EXCEPTIONS__"+                               , "__VA_ARGS__"+                               , "__VERSION__"+                               , "__WCHAR_MAX__"+                               , "__WCHAR_MIN__"+                               , "__WCHAR_TYPE__"+                               , "__WCHAR_UNSIGNED__"+                               , "__WINT_MAX__"+                               , "__WINT_MIN__"+                               , "__WINT_TYPE__"+                               , "__XOP__"+                               , "__XSAVEOPT__"+                               , "__XSAVE__"+                               , "__amd64"+                               , "__amd64__"+                               , "__amdfam10"+                               , "__amdfam10__"+                               , "__athlon"+                               , "__athlon__"+                               , "__athlon_sse__"+                               , "__atom"+                               , "__atom__"+                               , "__bdver1"+                               , "__bdver1__"+                               , "__bdver2"+                               , "__bdver2__"+                               , "__bdver3"+                               , "__bdver3__"+                               , "__btver1"+                               , "__btver1__"+                               , "__btver2"+                               , "__btver2__"+                               , "__code_model_32__"+                               , "__code_model_small__"+                               , "__core2"+                               , "__core2__"+                               , "__core_avx2"+                               , "__core_avx2__"+                               , "__corei7"+                               , "__corei7__"+                               , "__cplusplus"+                               , "__geode"+                               , "__geode__"+                               , "__gnu_linux__"+                               , "__i386"+                               , "__i386__"+                               , "__i486"+                               , "__i486__"+                               , "__i586"+                               , "__i586__"+                               , "__i686"+                               , "__i686__"+                               , "__k6"+                               , "__k6_2__"+                               , "__k6_3__"+                               , "__k6__"+                               , "__k8"+                               , "__k8__"+                               , "__linux"+                               , "__linux__"+                               , "__nocona"+                               , "__nocona__"+                               , "__pentium"+                               , "__pentium4"+                               , "__pentium4__"+                               , "__pentium__"+                               , "__pentium_mmx__"+                               , "__pentiumpro"+                               , "__pentiumpro__"+                               , "__pic__"+                               , "__pie__"+                               , "__tune_amdfam10__"+                               , "__tune_athlon__"+                               , "__tune_athlon_sse__"+                               , "__tune_atom__"+                               , "__tune_bdver1__"+                               , "__tune_bdver2__"+                               , "__tune_bdver3__"+                               , "__tune_btver1__"+                               , "__tune_btver2__"+                               , "__tune_core2__"+                               , "__tune_core_avx2__"+                               , "__tune_corei7__"+                               , "__tune_geode__"+                               , "__tune_i386__"+                               , "__tune_i486__"+                               , "__tune_i586__"+                               , "__tune_i686__"+                               , "__tune_k6_2__"+                               , "__tune_k6_3__"+                               , "__tune_k6__"+                               , "__tune_k8__"+                               , "__tune_nocona__"+                               , "__tune_pentium2__"+                               , "__tune_pentium3__"+                               , "__tune_pentium4__"+                               , "__tune_pentium__"+                               , "__tune_pentium_mmx__"+                               , "__tune_pentiumpro__"+                               , "__unix"+                               , "__unix__"+                               , "__x86_64"+                               , "__x86_64__"+                               , "i386"+                               , "linux"+                               , "unix"+                               ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Alex Turbov (i.zaufi@gmail.com)"+  , sVersion = "1"+  , sLicense = "LGPL"+  , sExtensions =+      [ "*.c++"+      , "*.cxx"+      , "*.cpp"+      , "*.cc"+      , "*.C"+      , "*.h"+      , "*.hh"+      , "*.H"+      , "*.h++"+      , "*.hxx"+      , "*.hpp"+      , "*.hcc"+      ]+  , sStartingContext = "DetectGccExtensions"+  }
+ src/Skylighting/Syntax/Glsl.hs view
@@ -0,0 +1,1513 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Glsl (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "GLSL"+  , sFilename = "glsl.xml"+  , sShortname = "Glsl"+  , sContexts =+      fromList+        [ ( "Commentar 1"+          , Context+              { cName = "Commentar 1"+              , cSyntax = "GLSL"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "BUG" , "FIXME" , "TODO" ])+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Commentar 2"+          , Context+              { cName = "Commentar 2"+              , cSyntax = "GLSL"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "BUG" , "FIXME" , "TODO" ])+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Member"+          , Context+              { cName = "Member"+              , cSyntax = "GLSL"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[_\\w][_\\w\\d]*(?=[\\s]*)"+                              , reCompiled =+                                  Just (compileRegex True "\\b[_\\w][_\\w\\d]*(?=[\\s]*)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "GLSL"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "break"+                               , "buffer"+                               , "continue"+                               , "discard"+                               , "do"+                               , "else"+                               , "false"+                               , "for"+                               , "if"+                               , "invariant"+                               , "layout"+                               , "return"+                               , "struct"+                               , "subroutine"+                               , "true"+                               , "uniform"+                               , "while"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "atomic_uint"+                               , "bool"+                               , "bvec2"+                               , "bvec3"+                               , "bvec4"+                               , "float"+                               , "int"+                               , "isampler1D"+                               , "isampler1DArray"+                               , "isampler1DArrayShadow"+                               , "isampler1DShadow"+                               , "isampler2D"+                               , "isampler2DArray"+                               , "isampler2DArrayShadow"+                               , "isampler2DMS"+                               , "isampler2DMSArray"+                               , "isampler2DRect"+                               , "isampler2DRectShadow"+                               , "isampler2DShadow"+                               , "isampler3D"+                               , "isamplerBuffer"+                               , "isamplerCube"+                               , "isamplerCubeArray"+                               , "isamplerCubeArrayShadow"+                               , "isamplerCubeShadow"+                               , "ivec2"+                               , "ivec3"+                               , "ivec4"+                               , "mat2"+                               , "mat3"+                               , "mat4"+                               , "sampler1D"+                               , "sampler1DArray"+                               , "sampler1DArrayShadow"+                               , "sampler1DShadow"+                               , "sampler2D"+                               , "sampler2DArray"+                               , "sampler2DArrayShadow"+                               , "sampler2DMS"+                               , "sampler2DMSArray"+                               , "sampler2DRect"+                               , "sampler2DRectShadow"+                               , "sampler2DShadow"+                               , "sampler3D"+                               , "samplerBuffer"+                               , "samplerCube"+                               , "samplerCubeArray"+                               , "samplerCubeArrayShadow"+                               , "samplerCubeShadow"+                               , "usampler1D"+                               , "usampler1DArray"+                               , "usampler1DArrayShadow"+                               , "usampler1DShadow"+                               , "usampler2D"+                               , "usampler2DArray"+                               , "usampler2DArrayShadow"+                               , "usampler2DMS"+                               , "usampler2DMSArray"+                               , "usampler2DRect"+                               , "usampler2DRectShadow"+                               , "usampler2DShadow"+                               , "usampler3D"+                               , "usamplerBuffer"+                               , "usamplerCube"+                               , "usamplerCubeArray"+                               , "usamplerCubeArrayShadow"+                               , "usamplerCubeShadow"+                               , "vec2"+                               , "vec3"+                               , "vec4"+                               , "void"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "attribute"+                               , "binding"+                               , "ccw"+                               , "coherent"+                               , "component"+                               , "const"+                               , "cw"+                               , "early_fragment_tests"+                               , "equal_spacing"+                               , "flat"+                               , "fractional_even_spacing"+                               , "fractional_odd_spacing"+                               , "in"+                               , "index"+                               , "inout"+                               , "invocations"+                               , "isolines"+                               , "line_strip"+                               , "lines"+                               , "lines_adjacency"+                               , "location"+                               , "max_vertices"+                               , "noperspective"+                               , "offset"+                               , "origin_upper_left"+                               , "out"+                               , "packed"+                               , "pixel_center_integer"+                               , "point_mode"+                               , "points"+                               , "quads"+                               , "readonly"+                               , "restrict"+                               , "row_major"+                               , "shared"+                               , "smooth"+                               , "std140"+                               , "std430"+                               , "stream"+                               , "triangle_strip"+                               , "triangles"+                               , "triangles_adjacency"+                               , "varying"+                               , "vertices"+                               , "volatile"+                               , "writeonly"+                               , "xfb_buffer"+                               , "xfb_offset"+                               , "xfb_stride"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "EmitStreamVertex"+                               , "EmitVertex"+                               , "EndPrimitive"+                               , "EndStreamPrimitive"+                               , "abs"+                               , "acos"+                               , "acosh"+                               , "all"+                               , "any"+                               , "asin"+                               , "asinh"+                               , "atan"+                               , "atanh"+                               , "atomicAdd"+                               , "atomicAnd"+                               , "atomicCompSwap"+                               , "atomicCounter"+                               , "atomicCounterDecrement"+                               , "atomicCounterIncrement"+                               , "atomicExchange"+                               , "atomicMax"+                               , "atomicMin"+                               , "atomicOr"+                               , "atomicXor"+                               , "barrier"+                               , "bitCount"+                               , "bitfieldExtract"+                               , "bitfieldInsert"+                               , "bitfieldReverse"+                               , "ceil"+                               , "clamp"+                               , "cos"+                               , "cosh"+                               , "cross"+                               , "dFdx"+                               , "dFdxCoarse"+                               , "dFdxFine"+                               , "dFdy"+                               , "dFdyCoarse"+                               , "dFdyFine"+                               , "degrees"+                               , "determinant"+                               , "distance"+                               , "dot"+                               , "equal"+                               , "exp"+                               , "exp2"+                               , "faceforward"+                               , "findLSB"+                               , "findMSB"+                               , "floatBitsToInt"+                               , "floatBitsToUint"+                               , "floor"+                               , "fma"+                               , "fract"+                               , "frexp"+                               , "fwidth"+                               , "fwidthCoarse"+                               , "fwidthFine"+                               , "glActiveShaderProgram"+                               , "glActiveTexture"+                               , "glAttachShader"+                               , "glBeginConditionalRender"+                               , "glBeginQuery"+                               , "glBeginQueryIndexed"+                               , "glBeginTransformFeedback"+                               , "glBindAttribLocation"+                               , "glBindBuffer"+                               , "glBindBufferBase"+                               , "glBindBufferRange"+                               , "glBindBuffersBase"+                               , "glBindBuffersRange"+                               , "glBindFragDataLocation"+                               , "glBindFragDataLocationIndexed"+                               , "glBindFramebuffer"+                               , "glBindImageTexture"+                               , "glBindImageTextures"+                               , "glBindProgramPipeline"+                               , "glBindRenderbuffer"+                               , "glBindSampler"+                               , "glBindSamplers"+                               , "glBindTexture"+                               , "glBindTextureUnit"+                               , "glBindTextures"+                               , "glBindTransformFeedback"+                               , "glBindVertexArray"+                               , "glBindVertexBuffer"+                               , "glBindVertexBuffers"+                               , "glBlendColor"+                               , "glBlendEquation"+                               , "glBlendEquationSeparate"+                               , "glBlendEquationSeparatei"+                               , "glBlendEquationi"+                               , "glBlendFunc"+                               , "glBlendFuncSeparate"+                               , "glBlendFuncSeparatei"+                               , "glBlendFunci"+                               , "glBlitFramebuffer"+                               , "glBlitNamedFramebuffer"+                               , "glBufferData"+                               , "glBufferStorage"+                               , "glBufferSubData"+                               , "glCheckFramebufferStatus"+                               , "glCheckNamedFramebufferStatus"+                               , "glClampColor"+                               , "glClear"+                               , "glClearBuffer"+                               , "glClearBufferData"+                               , "glClearBufferSubData"+                               , "glClearBufferfi"+                               , "glClearBufferfv"+                               , "glClearBufferiv"+                               , "glClearBufferuiv"+                               , "glClearColor"+                               , "glClearDepth"+                               , "glClearDepthf"+                               , "glClearNamedBufferData"+                               , "glClearNamedBufferSubData"+                               , "glClearNamedFramebufferfi"+                               , "glClearNamedFramebufferfv"+                               , "glClearNamedFramebufferiv"+                               , "glClearNamedFramebufferuiv"+                               , "glClearStencil"+                               , "glClearTexImage"+                               , "glClearTexSubImage"+                               , "glClientWaitSync"+                               , "glClipControl"+                               , "glColorMask"+                               , "glColorMaski"+                               , "glCompileShader"+                               , "glCompressedTexImage1D"+                               , "glCompressedTexImage2D"+                               , "glCompressedTexImage3D"+                               , "glCompressedTexSubImage1D"+                               , "glCompressedTexSubImage2D"+                               , "glCompressedTexSubImage3D"+                               , "glCompressedTextureSubImage1D"+                               , "glCompressedTextureSubImage2D"+                               , "glCompressedTextureSubImage3D"+                               , "glCopyBufferSubData"+                               , "glCopyImageSubData"+                               , "glCopyNamedBufferSubData"+                               , "glCopyTexImage1D"+                               , "glCopyTexImage2D"+                               , "glCopyTexSubImage1D"+                               , "glCopyTexSubImage2D"+                               , "glCopyTexSubImage3D"+                               , "glCopyTextureSubImage1D"+                               , "glCopyTextureSubImage2D"+                               , "glCopyTextureSubImage3D"+                               , "glCreateBuffers"+                               , "glCreateFramebuffers"+                               , "glCreateProgram"+                               , "glCreateProgramPipelines"+                               , "glCreateQueries"+                               , "glCreateRenderbuffers"+                               , "glCreateSamplers"+                               , "glCreateShader"+                               , "glCreateShaderProgram"+                               , "glCreateShaderProgramv"+                               , "glCreateTextures"+                               , "glCreateTransformFeedbacks"+                               , "glCreateVertexArrays"+                               , "glCullFace"+                               , "glDebugMessageCallback"+                               , "glDebugMessageControl"+                               , "glDebugMessageInsert"+                               , "glDeleteBuffers"+                               , "glDeleteFramebuffers"+                               , "glDeleteProgram"+                               , "glDeleteProgramPipelines"+                               , "glDeleteQueries"+                               , "glDeleteRenderbuffers"+                               , "glDeleteSamplers"+                               , "glDeleteShader"+                               , "glDeleteSync"+                               , "glDeleteTextures"+                               , "glDeleteTransformFeedbacks"+                               , "glDeleteVertexArrays"+                               , "glDepthFunc"+                               , "glDepthMask"+                               , "glDepthRange"+                               , "glDepthRangeArray"+                               , "glDepthRangeArrayv"+                               , "glDepthRangeIndexed"+                               , "glDepthRangef"+                               , "glDetachShader"+                               , "glDisable"+                               , "glDisableVertexArrayAttrib"+                               , "glDisableVertexAttribArray"+                               , "glDisablei"+                               , "glDispatchCompute"+                               , "glDispatchComputeIndirect"+                               , "glDrawArrays"+                               , "glDrawArraysIndirect"+                               , "glDrawArraysInstanced"+                               , "glDrawArraysInstancedBaseInstance"+                               , "glDrawBuffer"+                               , "glDrawBuffers"+                               , "glDrawElements"+                               , "glDrawElementsBaseVertex"+                               , "glDrawElementsIndirect"+                               , "glDrawElementsInstanced"+                               , "glDrawElementsInstancedBaseInstance"+                               , "glDrawElementsInstancedBaseVertex"+                               , "glDrawElementsInstancedBaseVertexBaseInstance"+                               , "glDrawRangeElements"+                               , "glDrawRangeElementsBaseVertex"+                               , "glDrawTransformFeedback"+                               , "glDrawTransformFeedbackInstanced"+                               , "glDrawTransformFeedbackStream"+                               , "glDrawTransformFeedbackStreamInstanced"+                               , "glEnable"+                               , "glEnableVertexArrayAttrib"+                               , "glEnableVertexAttribArray"+                               , "glEnablei"+                               , "glEndConditionalRender"+                               , "glEndQuery"+                               , "glEndQueryIndexed"+                               , "glEndTransformFeedback"+                               , "glFenceSync"+                               , "glFinish"+                               , "glFlush"+                               , "glFlushMappedBufferRange"+                               , "glFlushMappedNamedBufferRange"+                               , "glFramebufferParameteri"+                               , "glFramebufferRenderbuffer"+                               , "glFramebufferTexture"+                               , "glFramebufferTexture1D"+                               , "glFramebufferTexture2D"+                               , "glFramebufferTexture3D"+                               , "glFramebufferTextureLayer"+                               , "glFrontFace"+                               , "glGenBuffers"+                               , "glGenFramebuffers"+                               , "glGenProgramPipelines"+                               , "glGenQueries"+                               , "glGenRenderbuffers"+                               , "glGenSamplers"+                               , "glGenTextures"+                               , "glGenTransformFeedbacks"+                               , "glGenVertexArrays"+                               , "glGenerateMipmap"+                               , "glGenerateTextureMipmap"+                               , "glGet"+                               , "glGetActiveAtomicCounterBufferiv"+                               , "glGetActiveAttrib"+                               , "glGetActiveSubroutineName"+                               , "glGetActiveSubroutineUniform"+                               , "glGetActiveSubroutineUniformName"+                               , "glGetActiveSubroutineUniformiv"+                               , "glGetActiveUniform"+                               , "glGetActiveUniformBlock"+                               , "glGetActiveUniformBlockName"+                               , "glGetActiveUniformBlockiv"+                               , "glGetActiveUniformName"+                               , "glGetActiveUniformsiv"+                               , "glGetAttachedShaders"+                               , "glGetAttribLocation"+                               , "glGetBooleani_v"+                               , "glGetBooleanv"+                               , "glGetBufferParameter"+                               , "glGetBufferParameteri64v"+                               , "glGetBufferParameteriv"+                               , "glGetBufferPointerv"+                               , "glGetBufferSubData"+                               , "glGetCompressedTexImage"+                               , "glGetCompressedTextureImage"+                               , "glGetCompressedTextureSubImage"+                               , "glGetDebugMessageLog"+                               , "glGetDoublei_v"+                               , "glGetDoublev"+                               , "glGetError"+                               , "glGetFloati_v"+                               , "glGetFloatv"+                               , "glGetFragDataIndex"+                               , "glGetFragDataLocation"+                               , "glGetFramebufferAttachmentParameter"+                               , "glGetFramebufferAttachmentParameteriv"+                               , "glGetFramebufferParameter"+                               , "glGetFramebufferParameteriv"+                               , "glGetGraphicsResetStatus"+                               , "glGetInteger64i_v"+                               , "glGetInteger64v"+                               , "glGetIntegeri_v"+                               , "glGetIntegerv"+                               , "glGetInternalformat"+                               , "glGetInternalformati64v"+                               , "glGetInternalformativ"+                               , "glGetMultisample"+                               , "glGetMultisamplefv"+                               , "glGetNamedBufferParameteri64v"+                               , "glGetNamedBufferParameteriv"+                               , "glGetNamedBufferPointerv"+                               , "glGetNamedBufferSubData"+                               , "glGetNamedFramebufferAttachmentParameteriv"+                               , "glGetNamedFramebufferParameteriv"+                               , "glGetNamedRenderbufferParameteriv"+                               , "glGetObjectLabel"+                               , "glGetObjectPtrLabel"+                               , "glGetPointerv"+                               , "glGetProgram"+                               , "glGetProgramBinary"+                               , "glGetProgramInfoLog"+                               , "glGetProgramInterface"+                               , "glGetProgramInterfaceiv"+                               , "glGetProgramPipeline"+                               , "glGetProgramPipelineInfoLog"+                               , "glGetProgramPipelineiv"+                               , "glGetProgramResource"+                               , "glGetProgramResourceIndex"+                               , "glGetProgramResourceLocation"+                               , "glGetProgramResourceLocationIndex"+                               , "glGetProgramResourceName"+                               , "glGetProgramResourceiv"+                               , "glGetProgramStage"+                               , "glGetProgramStageiv"+                               , "glGetProgramiv"+                               , "glGetQueryIndexed"+                               , "glGetQueryIndexediv"+                               , "glGetQueryObject"+                               , "glGetQueryObjecti64v"+                               , "glGetQueryObjectiv"+                               , "glGetQueryObjectui64v"+                               , "glGetQueryObjectuiv"+                               , "glGetQueryiv"+                               , "glGetRenderbufferParameter"+                               , "glGetRenderbufferParameteriv"+                               , "glGetSamplerParameter"+                               , "glGetSamplerParameterIiv"+                               , "glGetSamplerParameterIuiv"+                               , "glGetSamplerParameterfv"+                               , "glGetSamplerParameteriv"+                               , "glGetShader"+                               , "glGetShaderInfoLog"+                               , "glGetShaderPrecisionFormat"+                               , "glGetShaderSource"+                               , "glGetShaderiv"+                               , "glGetString"+                               , "glGetStringi"+                               , "glGetSubroutineIndex"+                               , "glGetSubroutineUniformLocation"+                               , "glGetSync"+                               , "glGetSynciv"+                               , "glGetTexImage"+                               , "glGetTexLevelParameter"+                               , "glGetTexLevelParameterfv"+                               , "glGetTexLevelParameteriv"+                               , "glGetTexParameter"+                               , "glGetTexParameterIiv"+                               , "glGetTexParameterIuiv"+                               , "glGetTexParameterfv"+                               , "glGetTexParameteriv"+                               , "glGetTextureImage"+                               , "glGetTextureLevelParameterfv"+                               , "glGetTextureLevelParameteriv"+                               , "glGetTextureParameterIiv"+                               , "glGetTextureParameterIuiv"+                               , "glGetTextureParameterfv"+                               , "glGetTextureParameteriv"+                               , "glGetTextureSubImage"+                               , "glGetTransformFeedback"+                               , "glGetTransformFeedbackVarying"+                               , "glGetTransformFeedbacki64_v"+                               , "glGetTransformFeedbacki_v"+                               , "glGetTransformFeedbackiv"+                               , "glGetUniform"+                               , "glGetUniformBlockIndex"+                               , "glGetUniformIndices"+                               , "glGetUniformLocation"+                               , "glGetUniformSubroutine"+                               , "glGetUniformSubroutineuiv"+                               , "glGetUniformdv"+                               , "glGetUniformfv"+                               , "glGetUniformiv"+                               , "glGetUniformuiv"+                               , "glGetVertexArrayIndexed"+                               , "glGetVertexArrayIndexed64iv"+                               , "glGetVertexArrayIndexediv"+                               , "glGetVertexArrayiv"+                               , "glGetVertexAttrib"+                               , "glGetVertexAttribIiv"+                               , "glGetVertexAttribIuiv"+                               , "glGetVertexAttribLdv"+                               , "glGetVertexAttribPointerv"+                               , "glGetVertexAttribdv"+                               , "glGetVertexAttribfv"+                               , "glGetVertexAttribiv"+                               , "glGetnCompressedTexImage"+                               , "glGetnTexImage"+                               , "glGetnUniformdv"+                               , "glGetnUniformfv"+                               , "glGetnUniformiv"+                               , "glGetnUniformuiv"+                               , "glHint"+                               , "glInvalidateBufferData"+                               , "glInvalidateBufferSubData"+                               , "glInvalidateFramebuffer"+                               , "glInvalidateNamedFramebufferData"+                               , "glInvalidateNamedFramebufferSubData"+                               , "glInvalidateSubFramebuffer"+                               , "glInvalidateTexImage"+                               , "glInvalidateTexSubImage"+                               , "glIsBuffer"+                               , "glIsEnabled"+                               , "glIsEnabledi"+                               , "glIsFramebuffer"+                               , "glIsProgram"+                               , "glIsProgramPipeline"+                               , "glIsQuery"+                               , "glIsRenderbuffer"+                               , "glIsSampler"+                               , "glIsShader"+                               , "glIsSync"+                               , "glIsTexture"+                               , "glIsTransformFeedback"+                               , "glIsVertexArray"+                               , "glLineWidth"+                               , "glLinkProgram"+                               , "glLogicOp"+                               , "glMapBuffer"+                               , "glMapBufferRange"+                               , "glMapNamedBuffer"+                               , "glMapNamedBufferRange"+                               , "glMemoryBarrier"+                               , "glMemoryBarrierByRegion"+                               , "glMinSampleShading"+                               , "glMultiDrawArrays"+                               , "glMultiDrawArraysIndirect"+                               , "glMultiDrawElements"+                               , "glMultiDrawElementsBaseVertex"+                               , "glMultiDrawElementsIndirect"+                               , "glNamedBufferData"+                               , "glNamedBufferStorage"+                               , "glNamedBufferSubData"+                               , "glNamedFramebufferDrawBuffer"+                               , "glNamedFramebufferDrawBuffers"+                               , "glNamedFramebufferParameteri"+                               , "glNamedFramebufferReadBuffer"+                               , "glNamedFramebufferRenderbuffer"+                               , "glNamedFramebufferTexture"+                               , "glNamedFramebufferTextureLayer"+                               , "glNamedRenderbufferStorage"+                               , "glNamedRenderbufferStorageMultisample"+                               , "glObjectLabel"+                               , "glObjectPtrLabel"+                               , "glPatchParameter"+                               , "glPatchParameterfv"+                               , "glPatchParameteri"+                               , "glPauseTransformFeedback"+                               , "glPixelStore"+                               , "glPixelStoref"+                               , "glPixelStorei"+                               , "glPointParameter"+                               , "glPointParameterf"+                               , "glPointParameterfv"+                               , "glPointParameteri"+                               , "glPointParameteriv"+                               , "glPointSize"+                               , "glPolygonMode"+                               , "glPolygonOffset"+                               , "glPopDebugGroup"+                               , "glPrimitiveRestartIndex"+                               , "glProgramBinary"+                               , "glProgramParameter"+                               , "glProgramParameteri"+                               , "glProgramUniform"+                               , "glProgramUniform1f"+                               , "glProgramUniform1fv"+                               , "glProgramUniform1i"+                               , "glProgramUniform1iv"+                               , "glProgramUniform1ui"+                               , "glProgramUniform1uiv"+                               , "glProgramUniform2f"+                               , "glProgramUniform2fv"+                               , "glProgramUniform2i"+                               , "glProgramUniform2iv"+                               , "glProgramUniform2ui"+                               , "glProgramUniform2uiv"+                               , "glProgramUniform3f"+                               , "glProgramUniform3fv"+                               , "glProgramUniform3i"+                               , "glProgramUniform3iv"+                               , "glProgramUniform3ui"+                               , "glProgramUniform3uiv"+                               , "glProgramUniform4f"+                               , "glProgramUniform4fv"+                               , "glProgramUniform4i"+                               , "glProgramUniform4iv"+                               , "glProgramUniform4ui"+                               , "glProgramUniform4uiv"+                               , "glProgramUniformMatrix2fv"+                               , "glProgramUniformMatrix2x3fv"+                               , "glProgramUniformMatrix2x4fv"+                               , "glProgramUniformMatrix3fv"+                               , "glProgramUniformMatrix3x2fv"+                               , "glProgramUniformMatrix3x4fv"+                               , "glProgramUniformMatrix4fv"+                               , "glProgramUniformMatrix4x2fv"+                               , "glProgramUniformMatrix4x3fv"+                               , "glProvokingVertex"+                               , "glPushDebugGroup"+                               , "glQueryCounter"+                               , "glReadBuffer"+                               , "glReadPixels"+                               , "glReadnPixels"+                               , "glReleaseShaderCompiler"+                               , "glRenderbufferStorage"+                               , "glRenderbufferStorageMultisample"+                               , "glResumeTransformFeedback"+                               , "glSampleCoverage"+                               , "glSampleMaski"+                               , "glSamplerParameter"+                               , "glSamplerParameterIiv"+                               , "glSamplerParameterIuiv"+                               , "glSamplerParameterf"+                               , "glSamplerParameterfv"+                               , "glSamplerParameteri"+                               , "glSamplerParameteriv"+                               , "glScissor"+                               , "glScissorArray"+                               , "glScissorArrayv"+                               , "glScissorIndexed"+                               , "glScissorIndexedv"+                               , "glShaderBinary"+                               , "glShaderSource"+                               , "glShaderStorageBlockBinding"+                               , "glStencilFunc"+                               , "glStencilFuncSeparate"+                               , "glStencilMask"+                               , "glStencilMaskSeparate"+                               , "glStencilOp"+                               , "glStencilOpSeparate"+                               , "glTexBuffer"+                               , "glTexBufferRange"+                               , "glTexImage1D"+                               , "glTexImage2D"+                               , "glTexImage2DMultisample"+                               , "glTexImage3D"+                               , "glTexImage3DMultisample"+                               , "glTexParameter"+                               , "glTexParameterIiv"+                               , "glTexParameterIuiv"+                               , "glTexParameterf"+                               , "glTexParameterfv"+                               , "glTexParameteri"+                               , "glTexParameteriv"+                               , "glTexStorage1D"+                               , "glTexStorage2D"+                               , "glTexStorage2DMultisample"+                               , "glTexStorage3D"+                               , "glTexStorage3DMultisample"+                               , "glTexSubImage1D"+                               , "glTexSubImage2D"+                               , "glTexSubImage3D"+                               , "glTextureBarrier"+                               , "glTextureBuffer"+                               , "glTextureBufferRange"+                               , "glTextureParameterIiv"+                               , "glTextureParameterIuiv"+                               , "glTextureParameterf"+                               , "glTextureParameterfv"+                               , "glTextureParameteri"+                               , "glTextureParameteriv"+                               , "glTextureStorage1D"+                               , "glTextureStorage2D"+                               , "glTextureStorage2DMultisample"+                               , "glTextureStorage3D"+                               , "glTextureStorage3DMultisample"+                               , "glTextureSubImage1D"+                               , "glTextureSubImage2D"+                               , "glTextureSubImage3D"+                               , "glTextureView"+                               , "glTransformFeedbackBufferBase"+                               , "glTransformFeedbackBufferRange"+                               , "glTransformFeedbackVaryings"+                               , "glUniform"+                               , "glUniform1f"+                               , "glUniform1fv"+                               , "glUniform1i"+                               , "glUniform1iv"+                               , "glUniform1ui"+                               , "glUniform1uiv"+                               , "glUniform2f"+                               , "glUniform2fv"+                               , "glUniform2i"+                               , "glUniform2iv"+                               , "glUniform2ui"+                               , "glUniform2uiv"+                               , "glUniform3f"+                               , "glUniform3fv"+                               , "glUniform3i"+                               , "glUniform3iv"+                               , "glUniform3ui"+                               , "glUniform3uiv"+                               , "glUniform4f"+                               , "glUniform4fv"+                               , "glUniform4i"+                               , "glUniform4iv"+                               , "glUniform4ui"+                               , "glUniform4uiv"+                               , "glUniformBlockBinding"+                               , "glUniformMatrix2fv"+                               , "glUniformMatrix2x3fv"+                               , "glUniformMatrix2x4fv"+                               , "glUniformMatrix3fv"+                               , "glUniformMatrix3x2fv"+                               , "glUniformMatrix3x4fv"+                               , "glUniformMatrix4fv"+                               , "glUniformMatrix4x2fv"+                               , "glUniformMatrix4x3fv"+                               , "glUniformSubroutines"+                               , "glUniformSubroutinesuiv"+                               , "glUnmapBuffer"+                               , "glUnmapNamedBuffer"+                               , "glUseProgram"+                               , "glUseProgramStages"+                               , "glValidateProgram"+                               , "glValidateProgramPipeline"+                               , "glVertexArrayAttribBinding"+                               , "glVertexArrayAttribFormat"+                               , "glVertexArrayAttribIFormat"+                               , "glVertexArrayAttribLFormat"+                               , "glVertexArrayBindingDivisor"+                               , "glVertexArrayElementBuffer"+                               , "glVertexArrayVertexBuffer"+                               , "glVertexArrayVertexBuffers"+                               , "glVertexAttrib"+                               , "glVertexAttrib1d"+                               , "glVertexAttrib1dv"+                               , "glVertexAttrib1f"+                               , "glVertexAttrib1fv"+                               , "glVertexAttrib1s"+                               , "glVertexAttrib1sv"+                               , "glVertexAttrib2d"+                               , "glVertexAttrib2dv"+                               , "glVertexAttrib2f"+                               , "glVertexAttrib2fv"+                               , "glVertexAttrib2s"+                               , "glVertexAttrib2sv"+                               , "glVertexAttrib3d"+                               , "glVertexAttrib3dv"+                               , "glVertexAttrib3f"+                               , "glVertexAttrib3fv"+                               , "glVertexAttrib3s"+                               , "glVertexAttrib3sv"+                               , "glVertexAttrib4Nbv"+                               , "glVertexAttrib4Niv"+                               , "glVertexAttrib4Nsv"+                               , "glVertexAttrib4Nub"+                               , "glVertexAttrib4Nubv"+                               , "glVertexAttrib4Nuiv"+                               , "glVertexAttrib4Nusv"+                               , "glVertexAttrib4bv"+                               , "glVertexAttrib4d"+                               , "glVertexAttrib4dv"+                               , "glVertexAttrib4f"+                               , "glVertexAttrib4fv"+                               , "glVertexAttrib4iv"+                               , "glVertexAttrib4s"+                               , "glVertexAttrib4sv"+                               , "glVertexAttrib4ubv"+                               , "glVertexAttrib4uiv"+                               , "glVertexAttrib4usv"+                               , "glVertexAttribBinding"+                               , "glVertexAttribDivisor"+                               , "glVertexAttribFormat"+                               , "glVertexAttribI1i"+                               , "glVertexAttribI1iv"+                               , "glVertexAttribI1ui"+                               , "glVertexAttribI1uiv"+                               , "glVertexAttribI2i"+                               , "glVertexAttribI2iv"+                               , "glVertexAttribI2ui"+                               , "glVertexAttribI2uiv"+                               , "glVertexAttribI3i"+                               , "glVertexAttribI3iv"+                               , "glVertexAttribI3ui"+                               , "glVertexAttribI3uiv"+                               , "glVertexAttribI4bv"+                               , "glVertexAttribI4i"+                               , "glVertexAttribI4iv"+                               , "glVertexAttribI4sv"+                               , "glVertexAttribI4ubv"+                               , "glVertexAttribI4ui"+                               , "glVertexAttribI4uiv"+                               , "glVertexAttribI4usv"+                               , "glVertexAttribIFormat"+                               , "glVertexAttribIPointer"+                               , "glVertexAttribL1d"+                               , "glVertexAttribL1dv"+                               , "glVertexAttribL2d"+                               , "glVertexAttribL2dv"+                               , "glVertexAttribL3d"+                               , "glVertexAttribL3dv"+                               , "glVertexAttribL4d"+                               , "glVertexAttribL4dv"+                               , "glVertexAttribLFormat"+                               , "glVertexAttribLPointer"+                               , "glVertexAttribP1ui"+                               , "glVertexAttribP2ui"+                               , "glVertexAttribP3ui"+                               , "glVertexAttribP4ui"+                               , "glVertexAttribPointer"+                               , "glVertexBindingDivisor"+                               , "glViewport"+                               , "glViewportArray"+                               , "glViewportArrayv"+                               , "glViewportIndexed"+                               , "glViewportIndexedf"+                               , "glViewportIndexedfv"+                               , "glWaitSync"+                               , "gl_ClipDistance"+                               , "gl_CullDistance"+                               , "gl_FragCoord"+                               , "gl_FragDepth"+                               , "gl_FrontFacing"+                               , "gl_GlobalInvocationID"+                               , "gl_HelperInvocation"+                               , "gl_InstanceID"+                               , "gl_InvocationID"+                               , "gl_Layer"+                               , "gl_LocalInvocationID"+                               , "gl_LocalInvocationIndex"+                               , "gl_NumSamples"+                               , "gl_NumWorkGroups"+                               , "gl_PatchVerticesIn"+                               , "gl_PointCoord"+                               , "gl_PointSize"+                               , "gl_Position"+                               , "gl_PrimitiveID"+                               , "gl_PrimitiveIDIn"+                               , "gl_SampleID"+                               , "gl_SampleMask"+                               , "gl_SampleMaskIn"+                               , "gl_SamplePosition"+                               , "gl_TessCoord"+                               , "gl_TessLevelInner"+                               , "gl_TessLevelOuter"+                               , "gl_VertexID"+                               , "gl_ViewportIndex"+                               , "gl_WorkGroupID"+                               , "gl_WorkGroupSize"+                               , "greaterThan"+                               , "greaterThanEqual"+                               , "groupMemoryBarrier"+                               , "imageAtomicAdd"+                               , "imageAtomicAnd"+                               , "imageAtomicCompSwap"+                               , "imageAtomicExchange"+                               , "imageAtomicMax"+                               , "imageAtomicMin"+                               , "imageAtomicOr"+                               , "imageAtomicXor"+                               , "imageLoad"+                               , "imageSamples"+                               , "imageSize"+                               , "imageStore"+                               , "imulExtended"+                               , "intBitsToFloat"+                               , "interpolateAtCentroid"+                               , "interpolateAtOffset"+                               , "interpolateAtSample"+                               , "inverse"+                               , "inversesqrt"+                               , "isinf"+                               , "isnan"+                               , "ldexp"+                               , "length"+                               , "lessThan"+                               , "lessThanEqual"+                               , "log"+                               , "log2"+                               , "matrixCompMult"+                               , "max"+                               , "memoryBarrier"+                               , "memoryBarrierAtomicCounter"+                               , "memoryBarrierBuffer"+                               , "memoryBarrierImage"+                               , "memoryBarrierShared"+                               , "min"+                               , "mix"+                               , "mod"+                               , "modf"+                               , "noise"+                               , "noise1"+                               , "noise2"+                               , "noise3"+                               , "noise4"+                               , "normalize"+                               , "not"+                               , "notEqual"+                               , "outerProduct"+                               , "packDouble2x32"+                               , "packHalf2x16"+                               , "packSnorm2x16"+                               , "packSnorm4x8"+                               , "packUnorm"+                               , "packUnorm2x16"+                               , "packUnorm4x8"+                               , "pow"+                               , "radians"+                               , "reflect"+                               , "refract"+                               , "removedTypes"+                               , "round"+                               , "roundEven"+                               , "sign"+                               , "sin"+                               , "sinh"+                               , "smoothstep"+                               , "sqrt"+                               , "step"+                               , "tan"+                               , "tanh"+                               , "texelFetch"+                               , "texelFetchOffset"+                               , "texture"+                               , "textureGather"+                               , "textureGatherOffset"+                               , "textureGatherOffsets"+                               , "textureGrad"+                               , "textureGradOffset"+                               , "textureLod"+                               , "textureLodOffset"+                               , "textureOffset"+                               , "textureProj"+                               , "textureProjGrad"+                               , "textureProjGradOffset"+                               , "textureProjLod"+                               , "textureProjLodOffset"+                               , "textureProjOffset"+                               , "textureQueryLevels"+                               , "textureQueryLod"+                               , "textureSamples"+                               , "textureSize"+                               , "transpose"+                               , "trunc"+                               , "uaddCarry"+                               , "uintBitsToFloat"+                               , "umulExtended"+                               , "unpackDouble2x32"+                               , "unpackHalf2x16"+                               , "unpackSnorm2x16"+                               , "unpackSnorm4x8"+                               , "unpackUnorm"+                               , "unpackUnorm2x16"+                               , "unpackUnorm4x8"+                               , "usubBorrow"+                               ])+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "gl_BackColor"+                               , "gl_BackLightModelProduct"+                               , "gl_BackLightProduct"+                               , "gl_BackMaterial"+                               , "gl_BackSecondaryColor"+                               , "gl_ClipDistance"+                               , "gl_ClipPlane"+                               , "gl_ClipVertex"+                               , "gl_Color"+                               , "gl_DepthRange"+                               , "gl_DepthRangeParameters"+                               , "gl_EyePlaneQ"+                               , "gl_EyePlaneR"+                               , "gl_EyePlaneS"+                               , "gl_EyePlaneT"+                               , "gl_Fog"+                               , "gl_FogColor"+                               , "gl_FogFragCoord"+                               , "gl_FogParameters"+                               , "gl_FragColor"+                               , "gl_FragCoord"+                               , "gl_FragData"+                               , "gl_FragDepth"+                               , "gl_FragFacing"+                               , "gl_FrontColor"+                               , "gl_FrontLightModelProduct"+                               , "gl_FrontLightProduct"+                               , "gl_FrontMaterial"+                               , "gl_FrontSecondaryColor"+                               , "gl_InvocationID"+                               , "gl_Layer"+                               , "gl_LightModel"+                               , "gl_LightModelParameters"+                               , "gl_LightModelProducts"+                               , "gl_LightProducts"+                               , "gl_LightSource"+                               , "gl_LightSourceParameters"+                               , "gl_MaterialParameters"+                               , "gl_MaxClipPlanes"+                               , "gl_MaxCombinedTextureImageUnits"+                               , "gl_MaxDrawBuffers"+                               , "gl_MaxFragmentUniformComponents"+                               , "gl_MaxLights"+                               , "gl_MaxPatchVertices"+                               , "gl_MaxTextureCoords"+                               , "gl_MaxTextureImageUnits"+                               , "gl_MaxTextureUnits"+                               , "gl_MaxVaryingFloats"+                               , "gl_MaxVertexAttributes"+                               , "gl_MaxVertexTextureImageUnits"+                               , "gl_MaxVertexUniformComponents"+                               , "gl_ModelViewMatrix"+                               , "gl_ModelViewMatrixInverse"+                               , "gl_ModelViewMatrixInverseTranspose"+                               , "gl_ModelViewMatrixTranspose"+                               , "gl_ModelViewProjectionMatrix"+                               , "gl_ModelViewProjectionMatrixInverse"+                               , "gl_ModelViewProjectionMatrixInverseTranspose"+                               , "gl_ModelViewProjectionMatrixTranspose"+                               , "gl_MultiTexCoord0"+                               , "gl_MultiTexCoord1"+                               , "gl_MultiTexCoord2"+                               , "gl_MultiTexCoord3"+                               , "gl_MultiTexCoord4"+                               , "gl_MultiTexCoord5"+                               , "gl_MultiTexCoord6"+                               , "gl_MultiTexCoord7"+                               , "gl_NormScale"+                               , "gl_Normal"+                               , "gl_NormalMatrix"+                               , "gl_ObjectPlaneQ"+                               , "gl_ObjectPlaneR"+                               , "gl_ObjectPlaneS"+                               , "gl_ObjectPlaneT"+                               , "gl_PatchVerticesIn"+                               , "gl_Point"+                               , "gl_PointParameters"+                               , "gl_PointSize"+                               , "gl_Position"+                               , "gl_PrimitiveID"+                               , "gl_PrimitiveIDIn"+                               , "gl_ProjectionMatrix"+                               , "gl_ProjectionMatrixInverse"+                               , "gl_ProjectionMatrixInverseTranspose"+                               , "gl_ProjectionMatrixTranspose"+                               , "gl_SecondaryColor"+                               , "gl_TessCoord"+                               , "gl_TessLevelInner"+                               , "gl_TessLevelOuter"+                               , "gl_TexCoord"+                               , "gl_TextureEnvColor"+                               , "gl_TextureMatrix"+                               , "gl_TextureMatrixInverse"+                               , "gl_TextureMatrixInverseTranspose"+                               , "gl_TextureMatrixTranspose"+                               , "gl_Vertex"+                               , "gl_ViewportIndex"+                               , "gl_in"+                               , "gl_out"+                               ])+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "GLSL" , "Commentar 1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "GLSL" , "Commentar 2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "GLSL" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[_\\w][_\\w\\d]*(?=[\\s]*[(])"+                              , reCompiled =+                                  Just (compileRegex True "\\b[_\\w][_\\w\\d]*(?=[\\s]*[(])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[.]{1,1}"+                              , reCompiled = Just (compileRegex True "[.]{1,1}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "GLSL" , "Member" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar ".+-/*%<>[]()^|&~=!:;,?;"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Preprocessor"+          , Context+              { cName = "Preprocessor"+              , cSyntax = "GLSL"+              , cRules = []+              , cAttribute = PreprocessorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Oliver Richers (o.richers@tu-bs.de)"+  , sVersion = "3"+  , sLicense = "LGPL"+  , sExtensions =+      [ "*.glsl" , "*.vert" , "*.frag" , "*.geom" , "*.tcs" , "*.tes" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Gnuassembler.hs view
@@ -0,0 +1,688 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Gnuassembler (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "GNU Assembler"+  , sFilename = "gnuassembler.xml"+  , sShortname = "Gnuassembler"+  , sContexts =+      fromList+        [ ( "Commentar 1"+          , Context+              { cName = "Commentar 1"+              , cSyntax = "GNU Assembler"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Commentar 2"+          , Context+              { cName = "Commentar 2"+              , cSyntax = "GNU Assembler"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Define"+          , Context+              { cName = "Define"+              , cSyntax = "GNU Assembler"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = PreprocessorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "GNU Assembler"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[_\\w\\d-]*\\s*:"+                              , reCompiled = Just (compileRegex True "[_\\w\\d-]*\\s*:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ ".abort"+                               , ".align"+                               , ".app-file"+                               , ".appline"+                               , ".arm"+                               , ".ascii"+                               , ".asciz"+                               , ".att_syntax"+                               , ".balign"+                               , ".balignl"+                               , ".balignw"+                               , ".bss"+                               , ".byte"+                               , ".code"+                               , ".code16"+                               , ".code32"+                               , ".comm"+                               , ".common"+                               , ".common.s"+                               , ".data"+                               , ".dc"+                               , ".dc.b"+                               , ".dc.d"+                               , ".dc.l"+                               , ".dc.s"+                               , ".dc.w"+                               , ".dc.x"+                               , ".dcb"+                               , ".dcb.b"+                               , ".dcb.d"+                               , ".dcb.l"+                               , ".dcb.s"+                               , ".dcb.w"+                               , ".dcb.x"+                               , ".debug"+                               , ".def"+                               , ".desc"+                               , ".dim"+                               , ".double"+                               , ".ds"+                               , ".ds.b"+                               , ".ds.d"+                               , ".ds.l"+                               , ".ds.p"+                               , ".ds.s"+                               , ".ds.w"+                               , ".ds.x"+                               , ".dsect"+                               , ".eject"+                               , ".else"+                               , ".elsec"+                               , ".elseif"+                               , ".end"+                               , ".endc"+                               , ".endef"+                               , ".endfunc"+                               , ".endif"+                               , ".endm"+                               , ".endr"+                               , ".equ"+                               , ".equiv"+                               , ".err"+                               , ".even"+                               , ".exitm"+                               , ".extend"+                               , ".extern"+                               , ".fail"+                               , ".file"+                               , ".fill"+                               , ".float"+                               , ".force_thumb"+                               , ".format"+                               , ".func"+                               , ".global"+                               , ".globl"+                               , ".hidden"+                               , ".hword"+                               , ".ident"+                               , ".if"+                               , ".ifc"+                               , ".ifdef"+                               , ".ifeq"+                               , ".ifeqs"+                               , ".ifge"+                               , ".ifgt"+                               , ".ifle"+                               , ".iflt"+                               , ".ifnc"+                               , ".ifndef"+                               , ".ifne"+                               , ".ifnes"+                               , ".ifnotdef"+                               , ".include"+                               , ".int"+                               , ".intel_syntax"+                               , ".internal"+                               , ".irep"+                               , ".irepc"+                               , ".irp"+                               , ".irpc"+                               , ".lcomm"+                               , ".ldouble"+                               , ".lflags"+                               , ".line"+                               , ".linkonce"+                               , ".list"+                               , ".llen"+                               , ".ln"+                               , ".loc"+                               , ".long"+                               , ".lsym"+                               , ".ltorg"+                               , ".macro"+                               , ".mexit"+                               , ".name"+                               , ".noformat"+                               , ".nolist"+                               , ".nopage"+                               , ".octa"+                               , ".offset"+                               , ".org"+                               , ".p2align"+                               , ".p2alignl"+                               , ".p2alignw"+                               , ".packed"+                               , ".page"+                               , ".plen"+                               , ".pool"+                               , ".popsection"+                               , ".previous"+                               , ".print"+                               , ".protected"+                               , ".psize"+                               , ".purgem"+                               , ".pushsection"+                               , ".quad"+                               , ".rep"+                               , ".rept"+                               , ".req"+                               , ".rodata"+                               , ".rva"+                               , ".sbttl"+                               , ".scl"+                               , ".sect"+                               , ".sect.s"+                               , ".section"+                               , ".section.s"+                               , ".set"+                               , ".short"+                               , ".single"+                               , ".size"+                               , ".skip"+                               , ".sleb128"+                               , ".space"+                               , ".spc"+                               , ".stabd"+                               , ".stabn"+                               , ".stabs"+                               , ".string"+                               , ".struct"+                               , ".subsection"+                               , ".symver"+                               , ".tag"+                               , ".text"+                               , ".thumb"+                               , ".thumb_func"+                               , ".thumb_set"+                               , ".title"+                               , ".ttl"+                               , ".type"+                               , ".uleb128"+                               , ".use"+                               , ".val"+                               , ".version"+                               , ".vtable_entry"+                               , ".vtable_inherit"+                               , ".weak"+                               , ".word"+                               , ".xcom"+                               , ".xdef"+                               , ".xref"+                               , ".xstabs"+                               , ".zero"+                               , "noprefix"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "0[bB][01]+"+                              , reCompiled = Just (compileRegex True "0[bB][01]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "0[fFeEdD][-+]?[0-9]*\\.?[0-9]*[eE]?[-+]?[0-9]+"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "0[fFeEdD][-+]?[0-9]*\\.?[0-9]*[eE]?[-+]?[0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Za-z_.$][A-Za-z0-9_.$]*"+                              , reCompiled =+                                  Just (compileRegex True "[A-Za-z_.$][A-Za-z0-9_.$]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "'(\\\\x[0-9a-fA-F][0-9a-fA-F]?|\\\\[0-7]?[0-7]?[0-7]?|\\\\.|.)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "'(\\\\x[0-9a-fA-F][0-9a-fA-F]?|\\\\[0-7]?[0-7]?[0-7]?|\\\\.|.)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "GNU Assembler" , "String" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*if(?:def|ndef)?(?=\\s+\\S)"+                              , reCompiled =+                                  Just (compileRegex False "#\\s*if(?:def|ndef)?(?=\\s+\\S)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "GNU Assembler" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*endif"+                              , reCompiled = Just (compileRegex False "#\\s*endif")+                              , reCaseSensitive = False+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "GNU Assembler" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*define.*((?=\\\\))"+                              , reCompiled = Just (compileRegex False "#\\s*define.*((?=\\\\))")+                              , reCaseSensitive = False+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "GNU Assembler" , "Define" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "#\\s*(?:el(?:se|if)|include(?:_next)?|define|undef|line|error|warning|pragma)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "#\\s*(?:el(?:se|if)|include(?:_next)?|define|undef|line|error|warning|pragma)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "GNU Assembler" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "GNU Assembler" , "Commentar 1" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "@;#"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "GNU Assembler" , "Commentar 2" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "!#%&*()+,-<=>?/:[]^{|}~"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Preprocessor"+          , Context+              { cName = "Preprocessor"+              , cSyntax = "GNU Assembler"+              , cRules = []+              , cAttribute = PreprocessorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Some Context"+          , Context+              { cName = "Some Context"+              , cSyntax = "GNU Assembler"+              , cRules = []+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "GNU Assembler"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "GNU Assembler" , "Some Context" ) ]+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor =+      "John Zaitseff (J.Zaitseff@zap.org.au), Roland Pabel (roland@pabel.name), Miquel Sabat\233 (mikisabate@gmail.com)"+  , sVersion = "3"+  , sLicense = "GPLv2+"+  , sExtensions = [ "*.s" , "*.S" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Go.hs view
@@ -0,0 +1,562 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Go (syntax) where++import Skylighting.Types+import Data.Map+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Go"+  , sFilename = "go.xml"+  , sShortname = "Go"+  , sContexts =+      fromList+        [ ( "Commentar 1"+          , Context+              { cName = "Commentar 1"+              , cSyntax = "Go"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Commentar 2"+          , Context+              { cName = "Commentar 2"+              , cSyntax = "Go"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Multiline String"+          , Context+              { cName = "Multiline String"+              , cSyntax = "Go"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Go"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "normal"+          , Context+              { cName = "normal"+              , cSyntax = "Go"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "break"+                               , "case"+                               , "chan"+                               , "const"+                               , "continue"+                               , "default"+                               , "defer"+                               , "else"+                               , "fallthrough"+                               , "for"+                               , "func"+                               , "go"+                               , "goto"+                               , "if"+                               , "import"+                               , "interface"+                               , "map"+                               , "package"+                               , "range"+                               , "return"+                               , "select"+                               , "struct"+                               , "switch"+                               , "type"+                               , "var"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "false" , "iota" , "nil" , "true" ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "bool"+                               , "byte"+                               , "complex128"+                               , "complex64"+                               , "error"+                               , "float32"+                               , "float64"+                               , "int"+                               , "int16"+                               , "int32"+                               , "int64"+                               , "int8"+                               , "rune"+                               , "string"+                               , "uint"+                               , "uint16"+                               , "uint32"+                               , "uint64"+                               , "uint8"+                               , "uintptr"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "append"+                               , "cap"+                               , "close"+                               , "complex"+                               , "copy"+                               , "delete"+                               , "imag"+                               , "len"+                               , "make"+                               , "new"+                               , "panic"+                               , "print"+                               , "println"+                               , "real"+                               , "recover"+                               ])+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Go" , "Commentar 1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Go" , "Commentar 2" ) ]+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Go" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Go" , "Multiline String" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar ":!%&()+,-/.*<=>?[]|~^;"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Miquel Sabat\233 (mikisabate@gmail.com)"+  , sVersion = "3"+  , sLicense = "GPLv2+"+  , sExtensions = [ "*.go" ]+  , sStartingContext = "normal"+  }
+ src/Skylighting/Syntax/Hamlet.hs view
@@ -0,0 +1,688 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Hamlet (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex++syntax :: Syntax+syntax = Syntax+  { sName = "Hamlet"+  , sFilename = "hamlet.xml"+  , sShortname = "Hamlet"+  , sContexts =+      fromList+        [ ( "Assignment"+          , Context+              { cName = "Assignment"+              , cSyntax = "Hamlet"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<-"+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Hamlet" , "Codeline" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Haskell" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Attribute"+          , Context+              { cName = "Attribute"+              , cSyntax = "Hamlet"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Hamlet" , "Value" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Code"+          , Context+              { cName = "Code"+              , cSyntax = "Hamlet"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Haskell" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Codeline"+          , Context+              { cName = "Codeline"+              , cSyntax = "Hamlet"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Haskell" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Logic"+          , Context+              { cName = "Logic"+              , cSyntax = "Hamlet"+              , cRules =+                  [ Rule+                      { rMatcher = WordDetect "if"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Hamlet" , "Codeline" ) ]+                      }+                  , Rule+                      { rMatcher = WordDetect "elseif"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Hamlet" , "Codeline" ) ]+                      }+                  , Rule+                      { rMatcher = WordDetect "forall"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Hamlet" , "Assignment" ) ]+                      }+                  , Rule+                      { rMatcher = WordDetect "maybe"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Hamlet" , "Assignment" ) ]+                      }+                  , Rule+                      { rMatcher = WordDetect "else"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = WordDetect "nothing"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal Text"+          , Context+              { cName = "Normal Text"+              , cSyntax = "Hamlet"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<(?![0-9])[\\w_:][\\w.:_-]*\\b"+                              , reCompiled =+                                  Just (compileRegex True "<(?![0-9])[\\w_:][\\w.:_-]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Hamlet" , "element" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "^{"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Hamlet" , "Code" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "#{"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Hamlet" , "Code" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "@{"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Hamlet" , "Code" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "_{"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Hamlet" , "Code" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Hamlet" , "Logic" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Value"+          , Context+              { cName = "Value"+              , cSyntax = "Hamlet"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Hamlet" , "Value DQ" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Hamlet" , "Value SQ" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "@{"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Hamlet" , "Value Code" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "#{"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Hamlet" , "Value Code" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^\"'>\\s]+"+                              , reCompiled = Just (compileRegex True "[^\"'>\\s]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Value Code"+          , Context+              { cName = "Value Code"+              , cSyntax = "Hamlet"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Haskell" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Value DQ"+          , Context+              { cName = "Value DQ"+              , cSyntax = "Hamlet"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Value SQ"+          , Context+              { cName = "Value SQ"+              , cSyntax = "Hamlet"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "element"+          , Context+              { cName = "element"+              , cSyntax = "Hamlet"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(?![0-9])[\\w_:][\\w.:_-]*"+                              , reCompiled =+                                  Just (compileRegex True "(?![0-9])[\\w_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Hamlet" , "Attribute" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+(?![0-9])[\\w_:][\\w.:_-]*"+                              , reCompiled =+                                  Just (compileRegex True "\\s+(?![0-9])[\\w_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Hamlet" , "Attribute" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.(?![0-9])[\\w_:][\\w.:_-]*"+                              , reCompiled =+                                  Just (compileRegex True "\\.(?![0-9])[\\w_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Bastian Holst (bastianholst@gmx.de)"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions = [ "*.hamlet" ]+  , sStartingContext = "Normal Text"+  }
+ src/Skylighting/Syntax/Haskell.hs view
@@ -0,0 +1,2008 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Haskell (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Haskell"+  , sFilename = "haskell.xml"+  , sShortname = "Haskell"+  , sContexts =+      fromList+        [ ( "C Preprocessor"+          , Context+              { cName = "C Preprocessor"+              , cSyntax = "Haskell"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "defined" , "if" , "ifdef" , "ifndef" , "include" , "undef" ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ".*>$"+                              , reCompiled = Just (compileRegex True ".*>$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Haddock"+          , Context+              { cName = "Haddock"+              , cSyntax = "Haskell"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'([A-Z][a-zA-Z0-9_']*\\.)*[a-z_][a-zA-Z0-9_']*'"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "'([A-Z][a-zA-Z0-9_']*\\.)*[a-z_][a-zA-Z0-9_']*'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"([A-Z][a-zA-Z0-9_']*\\.)*[A-Z][a-zA-Z0-9_']*\""+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\"([A-Z][a-zA-Z0-9_']*\\.)*[A-Z][a-zA-Z0-9_']*\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/.*/"+                              , reCompiled = Just (compileRegex True "/.*/")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Haskell" , "Start Haddock Emphasis" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "__.*__"+                              , reCompiled = Just (compileRegex True "__.*__")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haskell" , "Start Haddock Bold" ) ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Haddock Bold"+          , Context+              { cName = "Haddock Bold"+              , cSyntax = "Haskell"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '_' '_'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Haskell" , "Haddock" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Haddock Emphasis"+          , Context+              { cName = "Haddock Emphasis"+              , cSyntax = "Haskell"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Haskell" , "Haddock" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Hamlet"+          , Context+              { cName = "Hamlet"+              , cSyntax = "Haskell"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Haskell" , "QuasiQuote" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Hamlet" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "QuasiQuote"+          , Context+              { cName = "QuasiQuote"+              , cSyntax = "Haskell"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '|' ']'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Start Haddock Bold"+          , Context+              { cName = "Start Haddock Bold"+              , cSyntax = "Haskell"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '_' '_'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haskell" , "Haddock Bold" ) ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Start Haddock Emphasis"+          , Context+              { cName = "Start Haddock Emphasis"+              , cSyntax = "Haskell"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haskell" , "Haddock Emphasis" ) ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "c2hs directive"+          , Context+              { cName = "c2hs directive"+              , cSyntax = "Haskell"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '#' '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "as"+                               , "call"+                               , "foreign"+                               , "get"+                               , "lib"+                               , "nocode"+                               , "prefix"+                               , "pure"+                               , "qualified"+                               , "set"+                               , "stable"+                               , "unsafe"+                               , "with"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "context"+                              , reCompiled = Just (compileRegex True "context")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "call"+                              , reCompiled = Just (compileRegex True "call")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "sizeof"+                              , reCompiled = Just (compileRegex True "sizeof")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "alignof"+                              , reCompiled = Just (compileRegex True "alignof")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "fun"+                              , reCompiled = Just (compileRegex True "fun")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haskell" , "c2hs fun" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "pointer"+                              , reCompiled = Just (compileRegex True "pointer")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haskell" , "c2hs pointer" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "enum"+                              , reCompiled = Just (compileRegex True "enum")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haskell" , "c2hs enum" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "import"+                              , reCompiled = Just (compileRegex True "import")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haskell" , "c2hs import" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "c2hs enum"+          , Context+              { cName = "c2hs enum"+              , cSyntax = "Haskell"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([A-Z][a-zA-Z0-9_']*\\.)*[A-Z][a-zA-Z0-9_']*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "([A-Z][a-zA-Z0-9_']*\\.)*[A-Z][a-zA-Z0-9_']*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "c2hs fun"+          , Context+              { cName = "c2hs fun"+              , cSyntax = "Haskell"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "as"+                               , "call"+                               , "foreign"+                               , "get"+                               , "lib"+                               , "nocode"+                               , "prefix"+                               , "pure"+                               , "qualified"+                               , "set"+                               , "stable"+                               , "unsafe"+                               , "with"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "`[^']*'"+                              , reCompiled = Just (compileRegex True "`[^']*'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "c2hs import"+          , Context+              { cName = "c2hs import"+              , cSyntax = "Haskell"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([A-Z][a-zA-Z0-9_']*\\.)*[A-Z][a-zA-Z0-9_']*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "([A-Z][a-zA-Z0-9_']*\\.)*[A-Z][a-zA-Z0-9_']*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "c2hs pointer"+          , Context+              { cName = "c2hs pointer"+              , cSyntax = "Haskell"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "as"+                               , "call"+                               , "foreign"+                               , "get"+                               , "lib"+                               , "nocode"+                               , "prefix"+                               , "pure"+                               , "qualified"+                               , "set"+                               , "stable"+                               , "unsafe"+                               , "with"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "newtype"+                              , reCompiled = Just (compileRegex True "newtype")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([A-Z][a-zA-Z0-9_']*\\.)*[A-Z][a-zA-Z0-9_']*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "([A-Z][a-zA-Z0-9_']*\\.)*[A-Z][a-zA-Z0-9_']*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "char"+          , Context+              { cName = "char"+              , cSyntax = "Haskell"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "code"+          , Context+              { cName = "code"+              , cSyntax = "Haskell"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{-#.*#-\\}"+                              , reCompiled = Just (compileRegex True "\\{-#.*#-\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "{--}"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{-[^#]?"+                              , reCompiled = Just (compileRegex True "\\{-[^#]?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haskell" , "comments" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "--[\\-]*([^!#\\$%&\\*\\+\\./<=>\\?@\\\\^\\|\\-~:]|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "--[\\-]*([^!#\\$%&\\*\\+\\./<=>\\?@\\\\^\\|\\-~:]|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haskell" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "import\\s+"+                              , reCompiled = Just (compileRegex True "import\\s+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haskell" , "import" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '{' '#'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haskell" , "c2hs directive" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Haskell" , "C Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "case"+                               , "class"+                               , "data"+                               , "deriving"+                               , "do"+                               , "else"+                               , "if"+                               , "in"+                               , "infixl"+                               , "infixr"+                               , "instance"+                               , "let"+                               , "module"+                               , "newtype"+                               , "of"+                               , "primitive"+                               , "then"+                               , "type"+                               , "where"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "FilePath"+                               , "IOError"+                               , "abs"+                               , "acos"+                               , "acosh"+                               , "all"+                               , "and"+                               , "any"+                               , "appendFile"+                               , "approxRational"+                               , "asTypeOf"+                               , "asin"+                               , "asinh"+                               , "atan"+                               , "atan2"+                               , "atanh"+                               , "basicIORun"+                               , "break"+                               , "catch"+                               , "ceiling"+                               , "chr"+                               , "compare"+                               , "concat"+                               , "concatMap"+                               , "const"+                               , "cos"+                               , "cosh"+                               , "curry"+                               , "cycle"+                               , "decodeFloat"+                               , "denominator"+                               , "digitToInt"+                               , "div"+                               , "divMod"+                               , "drop"+                               , "dropWhile"+                               , "either"+                               , "elem"+                               , "encodeFloat"+                               , "enumFrom"+                               , "enumFromThen"+                               , "enumFromThenTo"+                               , "enumFromTo"+                               , "error"+                               , "even"+                               , "exp"+                               , "exponent"+                               , "fail"+                               , "filter"+                               , "flip"+                               , "floatDigits"+                               , "floatRadix"+                               , "floatRange"+                               , "floor"+                               , "fmap"+                               , "foldMap"+                               , "foldl"+                               , "foldl1"+                               , "foldr"+                               , "foldr1"+                               , "fromDouble"+                               , "fromEnum"+                               , "fromInt"+                               , "fromInteger"+                               , "fromIntegral"+                               , "fromRational"+                               , "fst"+                               , "gcd"+                               , "getChar"+                               , "getContents"+                               , "getLine"+                               , "group"+                               , "head"+                               , "id"+                               , "inRange"+                               , "index"+                               , "init"+                               , "intToDigit"+                               , "interact"+                               , "ioError"+                               , "isAlpha"+                               , "isAlphaNum"+                               , "isAscii"+                               , "isControl"+                               , "isDenormalized"+                               , "isDigit"+                               , "isHexDigit"+                               , "isIEEE"+                               , "isInfinite"+                               , "isLower"+                               , "isNaN"+                               , "isNegativeZero"+                               , "isOctDigit"+                               , "isPrint"+                               , "isSpace"+                               , "isUpper"+                               , "iterate"+                               , "last"+                               , "lcm"+                               , "length"+                               , "lex"+                               , "lexDigits"+                               , "lexLitChar"+                               , "lines"+                               , "log"+                               , "logBase"+                               , "lookup"+                               , "map"+                               , "mapM"+                               , "mapM_"+                               , "mappend"+                               , "max"+                               , "maxBound"+                               , "maximum"+                               , "maybe"+                               , "mconcat"+                               , "mempty"+                               , "min"+                               , "minBound"+                               , "minimum"+                               , "mod"+                               , "negate"+                               , "not"+                               , "notElem"+                               , "null"+                               , "numerator"+                               , "odd"+                               , "or"+                               , "ord"+                               , "otherwise"+                               , "pack"+                               , "pi"+                               , "pred"+                               , "primExitWith"+                               , "print"+                               , "product"+                               , "properFraction"+                               , "pure"+                               , "putChar"+                               , "putStr"+                               , "putStrLn"+                               , "quot"+                               , "quotRem"+                               , "range"+                               , "rangeSize"+                               , "read"+                               , "readDec"+                               , "readFile"+                               , "readFloat"+                               , "readHex"+                               , "readIO"+                               , "readInt"+                               , "readList"+                               , "readLitChar"+                               , "readLn"+                               , "readOct"+                               , "readParen"+                               , "readSigned"+                               , "reads"+                               , "readsPrec"+                               , "realToFrac"+                               , "recip"+                               , "rem"+                               , "repeat"+                               , "replicate"+                               , "return"+                               , "reverse"+                               , "round"+                               , "scaleFloat"+                               , "scanl"+                               , "scanl1"+                               , "scanr"+                               , "scanr1"+                               , "seq"+                               , "sequence"+                               , "sequenceA"+                               , "sequence_"+                               , "show"+                               , "showChar"+                               , "showInt"+                               , "showList"+                               , "showLitChar"+                               , "showParen"+                               , "showSigned"+                               , "showString"+                               , "shows"+                               , "showsPrec"+                               , "significand"+                               , "signum"+                               , "sin"+                               , "sinh"+                               , "snd"+                               , "sort"+                               , "span"+                               , "splitAt"+                               , "sqrt"+                               , "subtract"+                               , "succ"+                               , "sum"+                               , "tail"+                               , "take"+                               , "takeWhile"+                               , "tan"+                               , "tanh"+                               , "threadToIOResult"+                               , "toEnum"+                               , "toInt"+                               , "toInteger"+                               , "toLower"+                               , "toRational"+                               , "toUpper"+                               , "traverse"+                               , "truncate"+                               , "uncurry"+                               , "undefined"+                               , "unlines"+                               , "until"+                               , "unwords"+                               , "unzip"+                               , "unzip3"+                               , "userError"+                               , "words"+                               , "writeFile"+                               , "zip"+                               , "zip3"+                               , "zipWith"+                               , "zipWith3"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Bool"+                               , "ByteString"+                               , "Char"+                               , "Double"+                               , "Either"+                               , "FilePath"+                               , "Float"+                               , "IO"+                               , "IOError"+                               , "Int"+                               , "Integer"+                               , "Maybe"+                               , "Ordering"+                               , "Ratio"+                               , "Rational"+                               , "ReadS"+                               , "ShowS"+                               , "String"+                               , "Word"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "EQ"+                               , "False"+                               , "GT"+                               , "Just"+                               , "LT"+                               , "Left"+                               , "Nothing"+                               , "Right"+                               , "True"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Applicative"+                               , "Bounded"+                               , "Enum"+                               , "Eq"+                               , "Floating"+                               , "Foldable"+                               , "Fractional"+                               , "Functor"+                               , "Integral"+                               , "Ix"+                               , "Monad"+                               , "Monoid"+                               , "Num"+                               , "Ord"+                               , "Read"+                               , "Real"+                               , "RealFloat"+                               , "RealFrac"+                               , "Show"+                               , "Traversable"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(::|=>|\\->|<\\-)"+                              , reCompiled = Just (compileRegex True "(::|=>|\\->|<\\-)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "\8759\8658\8594\8592\8704\8707"+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\s*[a-z_][a-zA-Z0-9_']*\\s*(?=::([^\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:]|$))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\s*[a-z_][a-zA-Z0-9_']*\\s*(?=::([^\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:]|$))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\s*(\\([\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:]*\\))*\\s*(?=::[^\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\s*(\\([\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:]*\\))*\\s*(?=::[^\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([A-Z][a-zA-Z0-9_']*\\.)*[a-z_][a-zA-Z0-9_']*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "([A-Z][a-zA-Z0-9_']*\\.)*[a-z_][a-zA-Z0-9_']*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "([A-Z][a-zA-Z0-0_']*\\.)*[\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:]+"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "([A-Z][a-zA-Z0-0_']*\\.)*[\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([A-Z][a-zA-Z0-9_']*\\.)*[A-Z][a-zA-Z0-9_']*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "([A-Z][a-zA-Z0-9_']*\\.)*[A-Z][a-zA-Z0-9_']*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\d+\\.\\d+([Ee][+-]?\\d+)?|\\d+[Ee][+-]?\\d+"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\d+\\.\\d+([Ee][+-]?\\d+)?|\\d+[Ee][+-]?\\d+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "0[Oo][0-7]+"+                              , reCompiled = Just (compileRegex True "0[Oo][0-7]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "0[Xx][0-9A-Fa-f]+"+                              , reCompiled = Just (compileRegex True "0[Xx][0-9A-Fa-f]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haskell" , "char" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haskell" , "string" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haskell" , "infix" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '.' '.'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "\8229"+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[[wx]?hamlet\\|"+                              , reCompiled = Just (compileRegex True "\\[[wx]?hamlet\\|")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haskell" , "Hamlet" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[[a-zA-Z_'](\\w|[_'])*\\|"+                              , reCompiled =+                                  Just (compileRegex True "\\[[a-zA-Z_'](\\w|[_'])*\\|")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haskell" , "QuasiQuote" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "comment"+          , Context+              { cName = "comment"+              , cSyntax = "Haskell"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Haskell" , "Haddock" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "comments"+          , Context+              { cName = "comments"+              , cSyntax = "Haskell"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '{' '-'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haskell" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '-' '}'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Haskell" , "Haddock" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "import"+          , Context+              { cName = "import"+              , cSyntax = "Haskell"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "as" , "hiding" , "qualified" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([A-Z][a-zA-Z0-9_']*\\.)*[a-z][a-zA-Z0-9_']*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "([A-Z][a-zA-Z0-9_']*\\.)*[a-z][a-zA-Z0-9_']*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([A-Z][a-zA-Z0-9_']*\\.)*[A-Z][a-zA-Z0-9_']*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "([A-Z][a-zA-Z0-9_']*\\.)*[A-Z][a-zA-Z0-9_']*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{-#.*#-\\}"+                              , reCompiled = Just (compileRegex True "\\{-#.*#-\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{-[^#]?"+                              , reCompiled = Just (compileRegex True "\\{-[^#]?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haskell" , "comments" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "--[^\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:].*$"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "--[^\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:].*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haskell" , "comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "infix"+          , Context+              { cName = "infix"+              , cSyntax = "Haskell"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "string"+          , Context+              { cName = "string"+              , cSyntax = "Haskell"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Nicolas Wu (zenzike@gmail.com)"+  , sVersion = "4"+  , sLicense = "LGPL"+  , sExtensions = [ "*.hs" , "*.chs" ]+  , sStartingContext = "code"+  }
+ src/Skylighting/Syntax/Haxe.hs view
@@ -0,0 +1,575 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Haxe (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Haxe"+  , sFilename = "haxe.xml"+  , sShortname = "Haxe"+  , sContexts =+      fromList+        [ ( "CommentBlock"+          , Context+              { cName = "CommentBlock"+              , cSyntax = "Haxe"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CommentLine"+          , Context+              { cName = "CommentLine"+              , cSyntax = "Haxe"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ModuleName"+          , Context+              { cName = "ModuleName"+              , cSyntax = "Haxe"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haxe" , "CommentLine" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haxe" , "CommentBlock" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^\\s\\w.:,]"+                              , reCompiled = Just (compileRegex True "[^\\s\\w.:,]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RawString"+          , Context+              { cName = "RawString"+              , cSyntax = "Haxe"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Haxe"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(u[\\da-fA-F]{4}|U[\\da-fA-F]{8}|&[a-zA-Z]\\w+;)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\\\(u[\\da-fA-F]{4}|U[\\da-fA-F]{8}|&[a-zA-Z]\\w+;)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "normal"+          , Context+              { cName = "normal"+              , cSyntax = "Haxe"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#if(\\s+\\w+)?"+                              , reCompiled = Just (compileRegex True "#if(\\s+\\w+)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#(else|elseif|end|error)"+                              , reCompiled = Just (compileRegex True "#(else|elseif|end|error)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "break"+                               , "case"+                               , "cast"+                               , "catch"+                               , "class"+                               , "continue"+                               , "default"+                               , "else"+                               , "enum"+                               , "extends"+                               , "false"+                               , "for"+                               , "function"+                               , "if"+                               , "implements"+                               , "in"+                               , "inline"+                               , "interface"+                               , "new"+                               , "null"+                               , "override"+                               , "private"+                               , "public"+                               , "return"+                               , "static"+                               , "super"+                               , "switch"+                               , "this"+                               , "throw"+                               , "trace"+                               , "true"+                               , "try"+                               , "typedef"+                               , "untyped"+                               , "var"+                               , "while"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "import" , "package" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haxe" , "ModuleName" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Array"+                               , "Bool"+                               , "Dynamic"+                               , "Error"+                               , "Float"+                               , "Int"+                               , "List"+                               , "String"+                               , "Type"+                               , "UInt"+                               , "Unknown"+                               , "Void"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haxe" , "RawString" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haxe" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haxe" , "CommentLine" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Haxe" , "CommentBlock" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "..."+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '.' '.'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\d][\\d]*(\\.(?!\\.)[\\d]*([eE][-+]?[\\d]+)?)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "[\\d][\\d]*(\\.(?!\\.)[\\d]*([eE][-+]?[\\d]+)?)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.[\\d][\\d]*([eE][-+]?[\\d]+)?"+                              , reCompiled =+                                  Just (compileRegex True "\\.[\\d][\\d]*([eE][-+]?[\\d]+)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "0[xX][\\da-fA-F]+"+                              , reCompiled = Just (compileRegex True "0[xX][\\da-fA-F]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\d+"+                              , reCompiled = Just (compileRegex True "\\d+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Chad Joan"+  , sVersion = "1"+  , sLicense = "MIT"+  , sExtensions = [ "*.hx" , "*.Hx" , "*.hX" , "*.HX" ]+  , sStartingContext = "normal"+  }
+ src/Skylighting/Syntax/Html.hs view
@@ -0,0 +1,2101 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Html (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex++syntax :: Syntax+syntax = Syntax+  { sName = "HTML"+  , sFilename = "html.xml"+  , sShortname = "Html"+  , sContexts =+      fromList+        [ ( "CDATA"+          , Context+              { cName = "CDATA"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "]]>"+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "]]&gt;"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CSS"+          , Context+              { cName = "CSS"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "CSS content" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "HTML" , "FindAttributes" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CSS content"+          , Context+              { cName = "CSS content"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</style\\b"+                              , reCompiled = Just (compileRegex False "</style\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Close 2" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = True+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "-->"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-(-(?!->))+"+                              , reCompiled = Just (compileRegex True "-(-(?!->))+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype"+          , Context+              { cName = "Doctype"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "Doctype Internal Subset" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Internal Subset"+          , Context+              { cName = "Doctype Internal Subset"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "HTML" , "FindDTDRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\?[\\w:-]*"+                              , reCompiled = Just (compileRegex True "<\\?[\\w:-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "PI" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "HTML" , "FindPEntityRefs" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Markupdecl"+          , Context+              { cName = "Doctype Markupdecl"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "Doctype Markupdecl DQ" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "Doctype Markupdecl SQ" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Markupdecl DQ"+          , Context+              { cName = "Doctype Markupdecl DQ"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "HTML" , "FindPEntityRefs" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Markupdecl SQ"+          , Context+              { cName = "Doctype Markupdecl SQ"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "HTML" , "FindPEntityRefs" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "El Close"+          , Context+              { cName = "El Close"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "El Close 2"+          , Context+              { cName = "El Close 2"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "El Close 3"+          , Context+              { cName = "El Close 3"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "El Open"+          , Context+              { cName = "El Open"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "HTML" , "FindAttributes" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindAttributes"+          , Context+              { cName = "FindAttributes"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Za-z_:][\\w.:_-]*"+                              , reCompiled = Just (compileRegex True "[A-Za-z_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+[A-Za-z_:][\\w.:_-]*"+                              , reCompiled = Just (compileRegex True "\\s+[A-Za-z_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "Value" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindDTDRules"+          , Context+              { cName = "FindDTDRules"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<!(ELEMENT|ENTITY|ATTLIST|NOTATION)\\b"+                              , reCompiled =+                                  Just (compileRegex True "<!(ELEMENT|ENTITY|ATTLIST|NOTATION)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "Doctype Markupdecl" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindEntityRefs"+          , Context+              { cName = "FindEntityRefs"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "&<"+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindHTML"+          , Context+              { cName = "FindHTML"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<![CDATA["+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "CDATA" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<!DOCTYPE\\s+"+                              , reCompiled = Just (compileRegex False "<!DOCTYPE\\s+")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "Doctype" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\?[\\w:-]*"+                              , reCompiled = Just (compileRegex True "<\\?[\\w:-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "PI" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<style\\b"+                              , reCompiled = Just (compileRegex False "<style\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "CSS" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<script\\b"+                              , reCompiled = Just (compileRegex False "<script\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "JS" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<pre\\b"+                              , reCompiled = Just (compileRegex False "<pre\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<div\\b"+                              , reCompiled = Just (compileRegex False "<div\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<table\\b"+                              , reCompiled = Just (compileRegex False "<table\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<ul\\b"+                              , reCompiled = Just (compileRegex False "<ul\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<ol\\b"+                              , reCompiled = Just (compileRegex False "<ol\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<dl\\b"+                              , reCompiled = Just (compileRegex False "<dl\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<article\\b"+                              , reCompiled = Just (compileRegex False "<article\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<aside\\b"+                              , reCompiled = Just (compileRegex False "<aside\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<details\\b"+                              , reCompiled = Just (compileRegex False "<details\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<figure\\b"+                              , reCompiled = Just (compileRegex False "<figure\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<footer\\b"+                              , reCompiled = Just (compileRegex False "<footer\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<header\\b"+                              , reCompiled = Just (compileRegex False "<header\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<main\\b"+                              , reCompiled = Just (compileRegex False "<main\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<nav\\b"+                              , reCompiled = Just (compileRegex False "<nav\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<section\\b"+                              , reCompiled = Just (compileRegex False "<section\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<[A-Za-z_:][\\w.:_-]*"+                              , reCompiled = Just (compileRegex True "<[A-Za-z_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</pre\\b"+                              , reCompiled = Just (compileRegex False "</pre\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</div\\b"+                              , reCompiled = Just (compileRegex False "</div\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</table\\b"+                              , reCompiled = Just (compileRegex False "</table\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</ul\\b"+                              , reCompiled = Just (compileRegex False "</ul\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</ol\\b"+                              , reCompiled = Just (compileRegex False "</ol\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</dl\\b"+                              , reCompiled = Just (compileRegex False "</dl\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</article\\b"+                              , reCompiled = Just (compileRegex False "</article\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</aside\\b"+                              , reCompiled = Just (compileRegex False "</aside\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</details\\b"+                              , reCompiled = Just (compileRegex False "</details\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</figure\\b"+                              , reCompiled = Just (compileRegex False "</figure\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</footer\\b"+                              , reCompiled = Just (compileRegex False "</footer\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</header\\b"+                              , reCompiled = Just (compileRegex False "</header\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</main\\b"+                              , reCompiled = Just (compileRegex False "</main\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</nav\\b"+                              , reCompiled = Just (compileRegex False "</nav\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</section\\b"+                              , reCompiled = Just (compileRegex False "</section\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</[A-Za-z_:][\\w.:_-]*"+                              , reCompiled = Just (compileRegex True "</[A-Za-z_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "HTML" , "FindDTDRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "HTML" , "FindEntityRefs" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindPEntityRefs"+          , Context+              { cName = "FindPEntityRefs"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%[A-Za-z_:][\\w.:_-]*;"+                              , reCompiled = Just (compileRegex True "%[A-Za-z_:][\\w.:_-]*;")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "&%"+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "JS"+          , Context+              { cName = "JS"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "JS content" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "HTML" , "FindAttributes" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "JS comment close"+          , Context+              { cName = "JS comment close"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</script\\b"+                              , reCompiled = Just (compileRegex False "</script\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Close 3" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "JS content"+          , Context+              { cName = "JS content"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</script\\b"+                              , reCompiled = Just (compileRegex False "</script\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "El Close 2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "//(?=.*</script\\b)"+                              , reCompiled = Just (compileRegex False "//(?=.*</script\\b)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "JS comment close" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "JavaScript" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = True+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "PI"+          , Context+              { cName = "PI"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '?' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Start"+          , Context+              { cName = "Start"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "HTML" , "FindHTML" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Value"+          , Context+              { cName = "Value"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "Value DQ" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "HTML" , "Value SQ" ) ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Push ( "HTML" , "Value NQ" ) ]+              , cDynamic = False+              }+          )+        , ( "Value DQ"+          , Context+              { cName = "Value DQ"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "HTML" , "FindEntityRefs" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Value NQ"+          , Context+              { cName = "Value NQ"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "HTML" , "FindEntityRefs" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/(?!>)"+                              , reCompiled = Just (compileRegex True "/(?!>)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^/><\"'\\s]"+                              , reCompiled = Just (compileRegex True "[^/><\"'\\s]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop , Pop ]+              , cDynamic = False+              }+          )+        , ( "Value SQ"+          , Context+              { cName = "Value SQ"+              , cSyntax = "HTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "HTML" , "FindEntityRefs" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Wilbert Berendsen (wilbert@kde.nl)"+  , sVersion = "4"+  , sLicense = "LGPL"+  , sExtensions = [ "*.htm" , "*.html" , "*.shtml" , "*.shtm" ]+  , sStartingContext = "Start"+  }
+ src/Skylighting/Syntax/Idris.hs view
@@ -0,0 +1,858 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Idris (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Idris"+  , sFilename = "idris.xml"+  , sShortname = "Idris"+  , sContexts =+      fromList+        [ ( "block comment"+          , Context+              { cName = "block comment"+              , cSyntax = "Idris"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '-' '}'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '{' '-'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Idris" , "block comment" ) ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "char"+          , Context+              { cName = "char"+              , cSyntax = "Idris"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "code"+          , Context+              { cName = "code"+              , cSyntax = "Idris"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "---*[^!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:]?"+                              , reCompiled =+                                  Just+                                    (compileRegex True "---*[^!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:]?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Idris" , "line comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\|\\|\\|[^\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:]?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\|\\|\\|[^\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:]?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Idris" , "line comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '{' '-'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Idris" , "block comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\s*([a-z]+\\s+)*([A-Za-z][A-Za-z0-9_]*'*|\\([\\-!#\\$%&\\*\\+\\./<=>\\?@\\\\^\\|~:]+\\))\\s*:"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\s*([a-z]+\\s+)*([A-Za-z][A-Za-z0-9_]*'*|\\([\\-!#\\$%&\\*\\+\\./<=>\\?@\\\\^\\|~:]+\\))\\s*:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Idris" , "declaration" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "abstract"+                               , "auto"+                               , "case"+                               , "class"+                               , "codata"+                               , "covering"+                               , "data"+                               , "default"+                               , "do"+                               , "dsl"+                               , "else"+                               , "if"+                               , "implicit"+                               , "import"+                               , "impossible"+                               , "in"+                               , "index_first"+                               , "index_next"+                               , "infix"+                               , "infixl"+                               , "infixr"+                               , "instance"+                               , "lambda"+                               , "let"+                               , "module"+                               , "mututal"+                               , "namespace"+                               , "of"+                               , "parameters"+                               , "partial"+                               , "pattern"+                               , "postulate"+                               , "prefix"+                               , "private"+                               , "proof"+                               , "public"+                               , "record"+                               , "rewrite"+                               , "static"+                               , "syntax"+                               , "tactics"+                               , "term"+                               , "then"+                               , "total"+                               , "using"+                               , "variable"+                               , "where"+                               , "with"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Idris" , "directive" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "applyTactic"+                               , "attack"+                               , "compute"+                               , "exact"+                               , "fill"+                               , "focus"+                               , "induction"+                               , "intro"+                               , "intros"+                               , "let"+                               , "refine"+                               , "reflect"+                               , "rewrite"+                               , "solve"+                               , "trivial"+                               , "try"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Idris" , "char" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Idris" , "string" ) ]+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "0[Xx][0-9A-Fa-f]+"+                              , reCompiled = Just (compileRegex True "0[Xx][0-9A-Fa-f]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "0[Xx][0-9A-Fa-f]+"+                              , reCompiled = Just (compileRegex True "0[Xx][0-9A-Fa-f]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\d+\\.\\d+([eE][-+]?\\d+)?"+                              , reCompiled =+                                  Just (compileRegex True "\\d+\\.\\d+([eE][-+]?\\d+)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([A-Z][a-zA-Z0-9_]*'*|_\\|_)"+                              , reCompiled =+                                  Just (compileRegex True "([A-Z][a-zA-Z0-9_]*'*|_\\|_)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-z][a-zA-Z0-9_]*'*"+                              , reCompiled = Just (compileRegex True "[a-z][a-zA-Z0-9_]*'*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\?[a-z][A-Za-z0-9_]+'*"+                              , reCompiled = Just (compileRegex True "\\?[a-z][A-Za-z0-9_]+'*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(:|=>|\\->|<\\-)"+                              , reCompiled = Just (compileRegex True "(:|=>|\\->|<\\-)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([\\-!#\\$%&\\*\\+\\./<=>\\?@\\\\^\\|~:]+|\\b_\\b)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "([\\-!#\\$%&\\*\\+\\./<=>\\?@\\\\^\\|~:]+|\\b_\\b)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "`[A-Za-z][A-Za-z0-9_]*'*`"+                              , reCompiled = Just (compileRegex True "`[A-Za-z][A-Za-z0-9_]*'*`")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "declaration"+          , Context+              { cName = "declaration"+              , cSyntax = "Idris"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "abstract"+                               , "auto"+                               , "case"+                               , "class"+                               , "codata"+                               , "covering"+                               , "data"+                               , "default"+                               , "do"+                               , "dsl"+                               , "else"+                               , "if"+                               , "implicit"+                               , "import"+                               , "impossible"+                               , "in"+                               , "index_first"+                               , "index_next"+                               , "infix"+                               , "infixl"+                               , "infixr"+                               , "instance"+                               , "lambda"+                               , "let"+                               , "module"+                               , "mututal"+                               , "namespace"+                               , "of"+                               , "parameters"+                               , "partial"+                               , "pattern"+                               , "postulate"+                               , "prefix"+                               , "private"+                               , "proof"+                               , "public"+                               , "record"+                               , "rewrite"+                               , "static"+                               , "syntax"+                               , "tactics"+                               , "term"+                               , "then"+                               , "total"+                               , "using"+                               , "variable"+                               , "where"+                               , "with"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([A-Z][a-zA-Z0-9_]*'*|_\\|_)"+                              , reCompiled =+                                  Just (compileRegex True "([A-Z][a-zA-Z0-9_]*'*|_\\|_)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-z][A-Za-z0-9_]*'*"+                              , reCompiled = Just (compileRegex True "[a-z][A-Za-z0-9_]*'*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\([\\-!#\\$%&\\*\\+\\./<=>\\?@\\\\^\\|~:]+\\)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\([\\-!#\\$%&\\*\\+\\./<=>\\?@\\\\^\\|~:]+\\)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "directive"+          , Context+              { cName = "directive"+              , cSyntax = "Idris"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "abstract"+                               , "auto"+                               , "case"+                               , "class"+                               , "codata"+                               , "covering"+                               , "data"+                               , "default"+                               , "do"+                               , "dsl"+                               , "else"+                               , "if"+                               , "implicit"+                               , "import"+                               , "impossible"+                               , "in"+                               , "index_first"+                               , "index_next"+                               , "infix"+                               , "infixl"+                               , "infixr"+                               , "instance"+                               , "lambda"+                               , "let"+                               , "module"+                               , "mututal"+                               , "namespace"+                               , "of"+                               , "parameters"+                               , "partial"+                               , "pattern"+                               , "postulate"+                               , "prefix"+                               , "private"+                               , "proof"+                               , "public"+                               , "record"+                               , "rewrite"+                               , "static"+                               , "syntax"+                               , "tactics"+                               , "term"+                               , "then"+                               , "total"+                               , "using"+                               , "variable"+                               , "where"+                               , "with"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "access"+                               , "assert_total"+                               , "default"+                               , "dynamic"+                               , "elim"+                               , "error_handlers"+                               , "error_reverse"+                               , "flag"+                               , "hide"+                               , "include"+                               , "language"+                               , "lib"+                               , "link"+                               , "name"+                               , "provide"+                               , "reflection"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "line comment"+          , Context+              { cName = "line comment"+              , cSyntax = "Idris"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "string"+          , Context+              { cName = "string"+              , cSyntax = "Idris"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\""+                              , reCompiled = Just (compileRegex True "\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Alexander Shabalin"+  , sVersion = "1.0"+  , sLicense = "LGPL"+  , sExtensions = [ "*.idr" ]+  , sStartingContext = "code"+  }
+ src/Skylighting/Syntax/Ini.hs view
@@ -0,0 +1,256 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Ini (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "INI Files"+  , sFilename = "ini.xml"+  , sShortname = "Ini"+  , sContexts =+      fromList+        [ ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "INI Files"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Value"+          , Context+              { cName = "Value"+              , cSyntax = "INI Files"+              , cRules =+                  [ Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "Default"+                               , "Defaults"+                               , "E_ALL"+                               , "E_COMPILE_ERROR"+                               , "E_COMPILE_WARNING"+                               , "E_CORE_ERROR"+                               , "E_CORE_WARNING"+                               , "E_ERROR"+                               , "E_NOTICE"+                               , "E_PARSE"+                               , "E_STRICT"+                               , "E_USER_ERROR"+                               , "E_USER_NOTICE"+                               , "E_USER_WARNING"+                               , "E_WARNING"+                               , "False"+                               , "Localhost"+                               , "No"+                               , "Normal"+                               , "Null"+                               , "Off"+                               , "On"+                               , "True"+                               , "Yes"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ";.*$"+                              , reCompiled = Just (compileRegex True ";.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#.*$"+                              , reCompiled = Just (compileRegex True "#.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ini"+          , Context+              { cName = "ini"+              , cSyntax = "INI Files"+              , cRules =+                  [ Rule+                      { rMatcher = RangeDetect '[' ']'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "INI Files" , "Value" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "INI Files" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "INI Files" , "Comment" ) ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Jan Janssen (medhefgo@web.de)"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions = [ "*.ini" , "*.pls" , "*.kcfgc" ]+  , sStartingContext = "ini"+  }
+ src/Skylighting/Syntax/Isocpp.hs view
@@ -0,0 +1,3062 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Isocpp (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "ISO C++"+  , sFilename = "isocpp.xml"+  , sShortname = "Isocpp"+  , sContexts =+      fromList+        [ ( "AfterHash"+          , Context+              { cName = "AfterHash"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*(?:include|include_next)"+                              , reCompiled =+                                  Just (compileRegex False "#\\s*(?:include|include_next)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Include" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(#|%\\:|\\?\\?=)\\s*if(?:def|ndef)?(?=(?:\\(|\\s+)\\S)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(#|%\\:|\\?\\?=)\\s*if(?:def|ndef)?(?=(?:\\(|\\s+)\\S)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(#|%\\:|\\?\\?=)\\s*endif"+                              , reCompiled = Just (compileRegex True "(#|%\\:|\\?\\?=)\\s*endif")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(#|%\\:|\\?\\?=)\\s*(cmake)?define.*((?=\\\\))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(#|%\\:|\\?\\?=)\\s*(cmake)?define.*((?=\\\\))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Define" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(#|%\\:|\\?\\?=)\\s*(?:el(?:se|if)|(cmake)?define|undef|line|error|warning|pragma)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(#|%\\:|\\?\\?=)\\s*(?:el(?:se|if)|(cmake)?define|undef|line|error|warning|pragma)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(#|%\\:|\\?\\?=)\\s+[0-9]+"+                              , reCompiled =+                                  Just (compileRegex True "(#|%\\:|\\?\\?=)\\s+[0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Preprocessor" ) ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Attribute"+          , Context+              { cName = "Attribute"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True [ "carries_dependency" , "deprecated" , "noreturn" ])+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars ']' ']'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = AnyChar "!% &()+-/.*<=>?[]{|}~^,;"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "String" ) ]+                      }+                  ]+              , cAttribute = AttributeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Boost Stuff"+          , Context+              { cName = "Boost Stuff"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "ISO C++" , "DetectNSEnd" )+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ExtensionTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Char Literal"+          , Context+              { cName = "Char Literal"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "ISO C++" , "Universal Char" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Simple Esc" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment 1"+          , Context+              { cName = "Comment 1"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Modelines" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment 2"+          , Context+              { cName = "Comment 2"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = LineContinue+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Modelines" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment/Preprocessor"+          , Context+              { cName = "Comment/Preprocessor"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Define"+          , Context+              { cName = "Define"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "__DATE__"+                               , "__FILE__"+                               , "__LINE__"+                               , "__STDC_HOSTED__"+                               , "__STDC_ISO_10646__"+                               , "__STDC_MB_MIGHT_NEQ_WC__"+                               , "__STDC_VERSION__"+                               , "__STDC__"+                               , "__TIME__"+                               , "__cplusplus"+                               , "__func__"+                               ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "GCCExtensions" , "GNUMacros" )+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = PreprocessorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DetectIdentifierEnd"+          , Context+              { cName = "DetectIdentifierEnd"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = AnyChar ":!% &()+-/.*<=>?[]{|}~^,;"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DetectNSEnd"+          , Context+              { cName = "DetectNSEnd"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "template" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar ",;"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = AnyChar "!% &()+-/.*<=>?[]{|}~^,;"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = AnyChar " "+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Include"+          , Context+              { cName = "Include"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = RangeDetect '"' '"'+                      , rAttribute = ImportTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = RangeDetect '<' '>'+                      , rAttribute = ImportTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "ISO C++" , "Preprocessor" )+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = PreprocessorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Inscoped"+          , Context+              { cName = "Inscoped"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(#|%\\:|\\?\\?=)\\s*if\\s+(0|false)\\s*"+                              , reCompiled =+                                  Just (compileRegex True "(#|%\\:|\\?\\?=)\\s*if\\s+(0|false)\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Outscoped" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(#|%\\:|\\?\\?=)\\s*el(?:se|if)"+                              , reCompiled =+                                  Just (compileRegex True "(#|%\\:|\\?\\?=)\\s*el(?:se|if)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Outscoped 2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(#|%\\:|\\?\\?=)\\s*endif"+                              , reCompiled = Just (compileRegex True "(#|%\\:|\\?\\?=)\\s*endif")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "ISO C++" , "Main" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "InternalsNS"+          , Context+              { cName = "InternalsNS"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "ISO C++" , "DetectNSEnd" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Main"+          , Context+              { cName = "Main"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "AfterHash" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '%' ':'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "AfterHash" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "??="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "AfterHash" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '%' ':'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "??="+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "//BEGIN"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Region Marker" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "//END"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Region Marker" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "operator\\s*\"\" _[_0-9A-Za-z]*\\b"+                              , reCompiled =+                                  Just (compileRegex True "operator\\s*\"\" _[_0-9A-Za-z]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "UDLOperator" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "operator\\s*\"\" [_0-9A-Za-z]*\\b"+                              , reCompiled =+                                  Just (compileRegex True "operator\\s*\"\" [_0-9A-Za-z]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "break"+                               , "case"+                               , "catch"+                               , "continue"+                               , "default"+                               , "do"+                               , "else"+                               , "for"+                               , "goto"+                               , "if"+                               , "return"+                               , "switch"+                               , "throw"+                               , "try"+                               , "while"+                               ])+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "alignas"+                               , "alignof"+                               , "and"+                               , "and_eq"+                               , "asm"+                               , "auto"+                               , "bitand"+                               , "bitor"+                               , "class"+                               , "compl"+                               , "const_cast"+                               , "constexpr"+                               , "decltype"+                               , "delete"+                               , "dynamic_cast"+                               , "enum"+                               , "explicit"+                               , "export"+                               , "false"+                               , "final"+                               , "friend"+                               , "inline"+                               , "namespace"+                               , "new"+                               , "noexcept"+                               , "not"+                               , "not_eq"+                               , "nullptr"+                               , "operator"+                               , "or"+                               , "or_eq"+                               , "override"+                               , "private"+                               , "protected"+                               , "public"+                               , "reinterpret_cast"+                               , "sizeof"+                               , "static_assert"+                               , "static_cast"+                               , "struct"+                               , "template"+                               , "this"+                               , "true"+                               , "typedef"+                               , "typeid"+                               , "typename"+                               , "union"+                               , "using"+                               , "virtual"+                               , "xor"+                               , "xor_eq"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '[' '['+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Attribute" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "[\\+\\-]?0x[0-9A-Fa-f]('?[0-9A-Fa-f]+)*([Uu][Ll]{0,2}|[Ll]{0,2}[Uu]?|_[_0-9A-Za-z]*)?\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "[\\+\\-]?0x[0-9A-Fa-f]('?[0-9A-Fa-f]+)*([Uu][Ll]{0,2}|[Ll]{0,2}[Uu]?|_[_0-9A-Za-z]*)?\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "0[Bb][01]('?[01]+)*([Uu][Ll]{0,2}|[Ll]{0,2}[Uu]?|_[_0-9A-Za-z]*)?\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "0[Bb][01]('?[01]+)*([Uu][Ll]{0,2}|[Ll]{0,2}[Uu]?|_[_0-9A-Za-z]*)?\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren =+                          [ Rule+                              { rMatcher = AnyChar "FfLl"+                              , rAttribute = FloatTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = True+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "[\\+\\-]?0'?[0-7]('?[0-7]+)*([Uu][Ll]{0,2}|[Ll]{0,2}[Uu]?|_[_0-9A-Za-z]*)?\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "[\\+\\-]?0'?[0-7]('?[0-7]+)*([Uu][Ll]{0,2}|[Ll]{0,2}[Uu]?|_[_0-9A-Za-z]*)?\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "[\\+\\-]?(0|[1-9]('?[0-9]+)*)([Uu][Ll]{0,2}|[Ll]{0,2}[Uu]?|_[_0-9A-Za-z]*)?\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "[\\+\\-]?(0|[1-9]('?[0-9]+)*)([Uu][Ll]{0,2}|[Ll]{0,2}[Uu]?|_[_0-9A-Za-z]*)?\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "[\\+\\-]?(0x?|[1-9][0-9]*)[0-9A-Za-z][_0-9A-Za-z]*\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "[\\+\\-]?(0x?|[1-9][0-9]*)[0-9A-Za-z][_0-9A-Za-z]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars 'U' '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars 'u' '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars 'L' '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "u8\""+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "String" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(u|u8|U|L)?R\"([^\\(]{0,16})\\("+                              , reCompiled =+                                  Just (compileRegex True "(u|u8|U|L)?R\"([^\\(]{0,16})\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "RawString" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(u|u8|U|L)?R\"([^\\(]{16,})\\("+                              , reCompiled =+                                  Just (compileRegex True "(u|u8|U|L)?R\"([^\\(]{16,})\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Char Literal" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars 'L' '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Char Literal" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars 'u' '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "U-Char Literal" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars 'U' '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "U-Char Literal" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "GCCExtensions" , "DetectGccExtensions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "std::"+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Standard Classes" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "boost::"+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Boost Stuff" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "BOOST_"+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Boost Stuff" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "detail::"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "InternalsNS" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "details::"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "InternalsNS" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "aux::"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "InternalsNS" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "internals::"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "InternalsNS" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "bool"+                               , "char"+                               , "char16_t"+                               , "char32_t"+                               , "double"+                               , "float"+                               , "int"+                               , "int16_t"+                               , "int32_t"+                               , "int64_t"+                               , "int8_t"+                               , "int_fast16_t"+                               , "int_fast32_t"+                               , "int_fast64_t"+                               , "int_fast8_t"+                               , "int_least16_t"+                               , "int_least32_t"+                               , "int_least64_t"+                               , "int_least8_t"+                               , "intmax_t"+                               , "intptr_t"+                               , "long"+                               , "ptrdiff_t"+                               , "short"+                               , "sig_atomic_t"+                               , "signed"+                               , "size_t"+                               , "ssize_t"+                               , "uint16_t"+                               , "uint32_t"+                               , "uint64_t"+                               , "uint8_t"+                               , "uint_fast16_t"+                               , "uint_fast32_t"+                               , "uint_fast64_t"+                               , "uint_fast8_t"+                               , "uint_least16_t"+                               , "uint_least32_t"+                               , "uint_least64_t"+                               , "uint_least8_t"+                               , "uintmax_t"+                               , "uintptr_t"+                               , "unsigned"+                               , "void"+                               , "wchar_t"+                               , "wint_t"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "const"+                               , "extern"+                               , "mutable"+                               , "register"+                               , "static"+                               , "thread_local"+                               , "volatile"+                               ])+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "__DATE__"+                               , "__FILE__"+                               , "__LINE__"+                               , "__STDC_HOSTED__"+                               , "__STDC_ISO_10646__"+                               , "__STDC_MB_MIGHT_NEQ_WC__"+                               , "__STDC_VERSION__"+                               , "__STDC__"+                               , "__TIME__"+                               , "__cplusplus"+                               , "__func__"+                               ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "_[a-zA-Z0-9_]+"+                              , reCompiled = Just (compileRegex True "_[a-zA-Z0-9_]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z][a-zA-Z0-9_]*__\\b"+                              , reCompiled =+                                  Just (compileRegex True "[a-zA-Z][a-zA-Z0-9_]*__\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-z][a-zA-Z0-9_]*_\\b"+                              , reCompiled = Just (compileRegex True "[a-z][a-zA-Z0-9_]*_\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "m_[a-zA-Z0-9_]+"+                              , reCompiled = Just (compileRegex True "m_[a-zA-Z0-9_]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "g_[a-zA-Z0-9_]+"+                              , reCompiled = Just (compileRegex True "g_[a-zA-Z0-9_]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "s_[a-zA-Z0-9_]+"+                              , reCompiled = Just (compileRegex True "s_[a-zA-Z0-9_]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Z][A-Z0-9_]{2,}\\b"+                              , reCompiled = Just (compileRegex True "[A-Z][A-Z0-9_]{2,}\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z][a-zA-Z0-9_]*_t(ype)?\\b"+                              , reCompiled =+                                  Just (compileRegex True "[a-zA-Z][a-zA-Z0-9_]*_t(ype)?\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Comment 1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Comment 2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar ",;"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar ":!% &()+-/.*<=>?[]{|}~^,;"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '@'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(#|%\\:|\\?\\?=)\\s*if\\s+(0|false)\\s*"+                              , reCompiled =+                                  Just (compileRegex True "(#|%\\:|\\?\\?=)\\s*if\\s+(0|false)\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Outscoped" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(#|%\\:|\\?\\?=)\\s*if\\s+(1|true)\\s*"+                              , reCompiled =+                                  Just (compileRegex True "(#|%\\:|\\?\\?=)\\s*if\\s+(1|true)\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Inscoped" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "ISO C++" , "Main" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Outscoped"+          , Context+              { cName = "Outscoped"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "ISO C++" , "Outscoped Common" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(#|%\\:|\\?\\?=)\\s*el(?:se|if)"+                              , reCompiled =+                                  Just (compileRegex True "(#|%\\:|\\?\\?=)\\s*el(?:se|if)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(#|%\\:|\\?\\?=)\\s*endif"+                              , reCompiled = Just (compileRegex True "(#|%\\:|\\?\\?=)\\s*endif")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Outscoped 2"+          , Context+              { cName = "Outscoped 2"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "ISO C++" , "Outscoped Common" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(#|%\\:|\\?\\?=)\\s*endif"+                              , reCompiled = Just (compileRegex True "(#|%\\:|\\?\\?=)\\s*endif")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Outscoped Common"+          , Context+              { cName = "Outscoped Common"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Modelines" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Comment 1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(#|%\\:|\\?\\?=)\\s*if"+                              , reCompiled = Just (compileRegex True "(#|%\\:|\\?\\?=)\\s*if")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Outscoped intern" ) ]+                      }+                  , Rule+                      { rMatcher = LineContinue+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Outscoped intern"+          , Context+              { cName = "Outscoped intern"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Modelines" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Comment 1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Comment 2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(#|%\\:|\\?\\?=)\\s*if"+                              , reCompiled = Just (compileRegex True "(#|%\\:|\\?\\?=)\\s*if")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Outscoped intern" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(#|%\\:|\\?\\?=)\\s*endif"+                              , reCompiled = Just (compileRegex True "(#|%\\:|\\?\\?=)\\s*endif")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Preprocessor"+          , Context+              { cName = "Preprocessor"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "__DATE__"+                               , "__FILE__"+                               , "__LINE__"+                               , "__STDC_HOSTED__"+                               , "__STDC_ISO_10646__"+                               , "__STDC_MB_MIGHT_NEQ_WC__"+                               , "__STDC_VERSION__"+                               , "__STDC__"+                               , "__TIME__"+                               , "__cplusplus"+                               , "__func__"+                               ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "GCCExtensions" , "GNUMacros" )+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "" )+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Comment/Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Comment 1" ) ]+                      }+                  ]+              , cAttribute = PreprocessorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RawString"+          , Context+              { cName = "RawString"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%[^\"diouxXeEfFgGaAcsP%\\s]*[diouxXeEfFgGaAcsP%]"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "%[^\"diouxXeEfFgGaAcsP%\\s]*[diouxXeEfFgGaAcsP%]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\)%2\""+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "Region Marker"+          , Context+              { cName = "Region Marker"+              , cSyntax = "ISO C++"+              , cRules = []+              , cAttribute = RegionMarkerTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Simple Esc"+          , Context+              { cName = "Simple Esc"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = AnyChar "tnvbrfa'\"\\"+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[0-7]{1,3}"+                              , reCompiled = Just (compileRegex True "[0-7]{1,3}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "x[0-9A-Fa-f]{1,}"+                              , reCompiled = Just (compileRegex True "x[0-9A-Fa-f]{1,}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = SpecialCharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Standard Classes"+          , Context+              { cName = "Standard Classes"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "ISO C++" , "DetectNSEnd" )+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = BuiltInTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "ISO C++" , "Universal Char" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%[^\"diouxXeEfFgGaAcsP%\\s]*[diouxXeEfFgGaAcsP%]"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "%[^\"diouxXeEfFgGaAcsP%\\s]*[diouxXeEfFgGaAcsP%]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "UDLStringSuffix" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "U-Char Literal"+          , Context+              { cName = "U-Char Literal"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "ISO C++" , "Universal Char" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "ISO C++" , "Simple Esc" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^']{2,}"+                              , reCompiled = Just (compileRegex True "[^']{2,}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ".{1}"+                              , reCompiled = Just (compileRegex True ".{1}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "UDLOperator"+          , Context+              { cName = "UDLOperator"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "operator"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "\"\""+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "UDLStringSuffix"+          , Context+              { cName = "UDLStringSuffix"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "_[_0-9A-Z-a-z]*\\b"+                              , reCompiled = Just (compileRegex True "_[_0-9A-Z-a-z]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ".*"+                              , reCompiled = Just (compileRegex True ".*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Universal Char"+          , Context+              { cName = "Universal Char"+              , cSyntax = "ISO C++"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\u[0-9A-Fa-f]{4}"+                              , reCompiled = Just (compileRegex True "\\\\u[0-9A-Fa-f]{4}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\u.{0,3}"+                              , reCompiled = Just (compileRegex True "\\\\u.{0,3}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\U[0-9A-Fa-f]{8}"+                              , reCompiled = Just (compileRegex True "\\\\U[0-9A-Fa-f]{8}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\U.{0,7}"+                              , reCompiled = Just (compileRegex True "\\\\U.{0,7}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = SpecialCharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Alex Turbov (i.zaufi@gmail.com)"+  , sVersion = "6"+  , sLicense = "LGPL"+  , sExtensions =+      [ "*.c++"+      , "*.cxx"+      , "*.cpp"+      , "*.cc"+      , "*.C"+      , "*.h"+      , "*.hh"+      , "*.H"+      , "*.h++"+      , "*.hxx"+      , "*.hpp"+      , "*.hcc"+      , "*.moc"+      ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Java.hs view
@@ -0,0 +1,4556 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Java (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Java"+  , sFilename = "java.xml"+  , sShortname = "Java"+  , sContexts =+      fromList+        [ ( "Commentar 1"+          , Context+              { cName = "Commentar 1"+              , cSyntax = "Java"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Commentar 2"+          , Context+              { cName = "Commentar 2"+              , cSyntax = "Java"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "EnterPrintf"+          , Context+              { cName = "EnterPrintf"+              , cSyntax = "Java"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Java" , "Printf" ) ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "Imports"+          , Context+              { cName = "Imports"+              , cSyntax = "Java"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*.*;"+                              , reCompiled = Just (compileRegex True "\\s*.*;")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ImportTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "InFunctionCall"+          , Context+              { cName = "InFunctionCall"+              , cSyntax = "Java"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Java" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Member"+          , Context+              { cName = "Member"+              , cSyntax = "Java"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[_a-zA-Z]\\w*(?=[\\s]*)"+                              , reCompiled =+                                  Just (compileRegex True "\\b[_a-zA-Z]\\w*(?=[\\s]*)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Java"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Javadoc" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "@interface"+                               , "abstract"+                               , "break"+                               , "case"+                               , "catch"+                               , "class"+                               , "continue"+                               , "default"+                               , "do"+                               , "else"+                               , "enum"+                               , "extends"+                               , "false"+                               , "finally"+                               , "for"+                               , "goto"+                               , "if"+                               , "implements"+                               , "instanceof"+                               , "interface"+                               , "native"+                               , "new"+                               , "null"+                               , "private"+                               , "protected"+                               , "public"+                               , "return"+                               , "strictfp"+                               , "super"+                               , "switch"+                               , "synchronized"+                               , "this"+                               , "throw"+                               , "throws"+                               , "transient"+                               , "true"+                               , "try"+                               , "volatile"+                               , "while"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "boolean"+                               , "byte"+                               , "char"+                               , "const"+                               , "double"+                               , "final"+                               , "float"+                               , "int"+                               , "long"+                               , "short"+                               , "static"+                               , "void"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ACTIVE"+                               , "ACTIVITY_COMPLETED"+                               , "ACTIVITY_REQUIRED"+                               , "ARG_IN"+                               , "ARG_INOUT"+                               , "ARG_OUT"+                               , "AWTError"+                               , "AWTEvent"+                               , "AWTEventListener"+                               , "AWTEventListenerProxy"+                               , "AWTEventMulticaster"+                               , "AWTException"+                               , "AWTKeyStroke"+                               , "AWTPermission"+                               , "AbstractAction"+                               , "AbstractAnnotationValueVisitor6"+                               , "AbstractBorder"+                               , "AbstractButton"+                               , "AbstractCellEditor"+                               , "AbstractCollection"+                               , "AbstractColorChooserPanel"+                               , "AbstractDocument"+                               , "AbstractDocument.AttributeContext"+                               , "AbstractDocument.Content"+                               , "AbstractDocument.ElementEdit"+                               , "AbstractElementVisitor6"+                               , "AbstractExecutorService"+                               , "AbstractInterruptibleChannel"+                               , "AbstractLayoutCache"+                               , "AbstractLayoutCache.NodeDimensions"+                               , "AbstractList"+                               , "AbstractListModel"+                               , "AbstractMap"+                               , "AbstractMarshallerImpl"+                               , "AbstractMethodError"+                               , "AbstractOwnableSynchronizer"+                               , "AbstractPreferences"+                               , "AbstractProcessor"+                               , "AbstractQueue"+                               , "AbstractQueuedLongSynchronizer"+                               , "AbstractQueuedSynchronizer"+                               , "AbstractScriptEngine"+                               , "AbstractSelectableChannel"+                               , "AbstractSelectionKey"+                               , "AbstractSelector"+                               , "AbstractSequentialList"+                               , "AbstractSet"+                               , "AbstractSpinnerModel"+                               , "AbstractTableModel"+                               , "AbstractTypeVisitor6"+                               , "AbstractUndoableEdit"+                               , "AbstractUnmarshallerImpl"+                               , "AbstractWriter"+                               , "AccessControlContext"+                               , "AccessControlException"+                               , "AccessController"+                               , "AccessException"+                               , "Accessible"+                               , "AccessibleAction"+                               , "AccessibleAttributeSequence"+                               , "AccessibleBundle"+                               , "AccessibleComponent"+                               , "AccessibleContext"+                               , "AccessibleEditableText"+                               , "AccessibleExtendedComponent"+                               , "AccessibleExtendedTable"+                               , "AccessibleExtendedText"+                               , "AccessibleHyperlink"+                               , "AccessibleHypertext"+                               , "AccessibleIcon"+                               , "AccessibleKeyBinding"+                               , "AccessibleObject"+                               , "AccessibleRelation"+                               , "AccessibleRelationSet"+                               , "AccessibleResourceBundle"+                               , "AccessibleRole"+                               , "AccessibleSelection"+                               , "AccessibleState"+                               , "AccessibleStateSet"+                               , "AccessibleStreamable"+                               , "AccessibleTable"+                               , "AccessibleTableModelChange"+                               , "AccessibleText"+                               , "AccessibleTextSequence"+                               , "AccessibleValue"+                               , "AccountException"+                               , "AccountExpiredException"+                               , "AccountLockedException"+                               , "AccountNotFoundException"+                               , "Acl"+                               , "AclEntry"+                               , "AclNotFoundException"+                               , "Action"+                               , "ActionEvent"+                               , "ActionListener"+                               , "ActionMap"+                               , "ActionMapUIResource"+                               , "Activatable"+                               , "ActivateFailedException"+                               , "ActivationDataFlavor"+                               , "ActivationDesc"+                               , "ActivationException"+                               , "ActivationGroup"+                               , "ActivationGroupDesc"+                               , "ActivationGroupDesc.CommandEnvironment"+                               , "ActivationGroupID"+                               , "ActivationGroup_Stub"+                               , "ActivationID"+                               , "ActivationInstantiator"+                               , "ActivationMonitor"+                               , "ActivationSystem"+                               , "Activator"+                               , "ActiveEvent"+                               , "ActivityCompletedException"+                               , "ActivityRequiredException"+                               , "AdapterActivator"+                               , "AdapterActivatorOperations"+                               , "AdapterAlreadyExists"+                               , "AdapterAlreadyExistsHelper"+                               , "AdapterInactive"+                               , "AdapterInactiveHelper"+                               , "AdapterManagerIdHelper"+                               , "AdapterNameHelper"+                               , "AdapterNonExistent"+                               , "AdapterNonExistentHelper"+                               , "AdapterStateHelper"+                               , "AddressHelper"+                               , "Adjustable"+                               , "AdjustmentEvent"+                               , "AdjustmentListener"+                               , "Adler32"+                               , "AffineTransform"+                               , "AffineTransformOp"+                               , "AlgorithmMethod"+                               , "AlgorithmParameterGenerator"+                               , "AlgorithmParameterGeneratorSpi"+                               , "AlgorithmParameterSpec"+                               , "AlgorithmParameters"+                               , "AlgorithmParametersSpi"+                               , "AllPermission"+                               , "AlphaComposite"+                               , "AlreadyBound"+                               , "AlreadyBoundException"+                               , "AlreadyBoundHelper"+                               , "AlreadyBoundHolder"+                               , "AlreadyConnectedException"+                               , "AncestorEvent"+                               , "AncestorListener"+                               , "AnnotatedElement"+                               , "Annotation"+                               , "AnnotationFormatError"+                               , "AnnotationMirror"+                               , "AnnotationTypeMismatchException"+                               , "AnnotationValue"+                               , "AnnotationValueVisitor"+                               , "Any"+                               , "AnyHolder"+                               , "AnySeqHelper"+                               , "AnySeqHolder"+                               , "AppConfigurationEntry"+                               , "AppConfigurationEntry.LoginModuleControlFlag"+                               , "Appendable"+                               , "Applet"+                               , "AppletContext"+                               , "AppletInitializer"+                               , "AppletStub"+                               , "ApplicationException"+                               , "Arc2D"+                               , "Arc2D.Double"+                               , "Arc2D.Float"+                               , "Area"+                               , "AreaAveragingScaleFilter"+                               , "ArithmeticException"+                               , "Array"+                               , "ArrayBlockingQueue"+                               , "ArrayDeque"+                               , "ArrayIndexOutOfBoundsException"+                               , "ArrayList"+                               , "ArrayStoreException"+                               , "ArrayType"+                               , "Arrays"+                               , "AssertionError"+                               , "AsyncBoxView"+                               , "AsyncHandler"+                               , "AsynchronousCloseException"+                               , "AtomicBoolean"+                               , "AtomicInteger"+                               , "AtomicIntegerArray"+                               , "AtomicIntegerFieldUpdater"+                               , "AtomicLong"+                               , "AtomicLongArray"+                               , "AtomicLongFieldUpdater"+                               , "AtomicMarkableReference"+                               , "AtomicReference"+                               , "AtomicReferenceArray"+                               , "AtomicReferenceFieldUpdater"+                               , "AtomicStampedReference"+                               , "AttachmentMarshaller"+                               , "AttachmentPart"+                               , "AttachmentUnmarshaller"+                               , "Attr"+                               , "Attribute"+                               , "AttributeChangeNotification"+                               , "AttributeChangeNotificationFilter"+                               , "AttributeException"+                               , "AttributeInUseException"+                               , "AttributeList"+                               , "AttributeListImpl"+                               , "AttributeModificationException"+                               , "AttributeNotFoundException"+                               , "AttributeSet"+                               , "AttributeSet.CharacterAttribute"+                               , "AttributeSet.ColorAttribute"+                               , "AttributeSet.FontAttribute"+                               , "AttributeSet.ParagraphAttribute"+                               , "AttributeSetUtilities"+                               , "AttributeValueExp"+                               , "AttributedCharacterIterator"+                               , "AttributedCharacterIterator.Attribute"+                               , "AttributedString"+                               , "Attributes"+                               , "Attributes.Name"+                               , "Attributes2"+                               , "Attributes2Impl"+                               , "AttributesImpl"+                               , "AudioClip"+                               , "AudioFileFormat"+                               , "AudioFileFormat.Type"+                               , "AudioFileReader"+                               , "AudioFileWriter"+                               , "AudioFormat"+                               , "AudioFormat.Encoding"+                               , "AudioInputStream"+                               , "AudioPermission"+                               , "AudioSystem"+                               , "AuthPermission"+                               , "AuthProvider"+                               , "AuthenticationException"+                               , "AuthenticationNotSupportedException"+                               , "Authenticator"+                               , "Authenticator.RequestorType"+                               , "AuthorizeCallback"+                               , "Autoscroll"+                               , "BAD_CONTEXT"+                               , "BAD_INV_ORDER"+                               , "BAD_OPERATION"+                               , "BAD_PARAM"+                               , "BAD_POLICY"+                               , "BAD_POLICY_TYPE"+                               , "BAD_POLICY_VALUE"+                               , "BAD_QOS"+                               , "BAD_TYPECODE"+                               , "BMPImageWriteParam"+                               , "BackingStoreException"+                               , "BadAttributeValueExpException"+                               , "BadBinaryOpValueExpException"+                               , "BadKind"+                               , "BadLocationException"+                               , "BadPaddingException"+                               , "BadStringOperationException"+                               , "BandCombineOp"+                               , "BandedSampleModel"+                               , "BaseRowSet"+                               , "BasicArrowButton"+                               , "BasicAttribute"+                               , "BasicAttributes"+                               , "BasicBorders"+                               , "BasicBorders.ButtonBorder"+                               , "BasicBorders.FieldBorder"+                               , "BasicBorders.MarginBorder"+                               , "BasicBorders.MenuBarBorder"+                               , "BasicBorders.RadioButtonBorder"+                               , "BasicBorders.RolloverButtonBorder"+                               , "BasicBorders.SplitPaneBorder"+                               , "BasicBorders.ToggleButtonBorder"+                               , "BasicButtonListener"+                               , "BasicButtonUI"+                               , "BasicCheckBoxMenuItemUI"+                               , "BasicCheckBoxUI"+                               , "BasicColorChooserUI"+                               , "BasicComboBoxEditor"+                               , "BasicComboBoxEditor.UIResource"+                               , "BasicComboBoxRenderer"+                               , "BasicComboBoxRenderer.UIResource"+                               , "BasicComboBoxUI"+                               , "BasicComboPopup"+                               , "BasicControl"+                               , "BasicDesktopIconUI"+                               , "BasicDesktopPaneUI"+                               , "BasicDirectoryModel"+                               , "BasicEditorPaneUI"+                               , "BasicFileChooserUI"+                               , "BasicFormattedTextFieldUI"+                               , "BasicGraphicsUtils"+                               , "BasicHTML"+                               , "BasicIconFactory"+                               , "BasicInternalFrameTitlePane"+                               , "BasicInternalFrameUI"+                               , "BasicLabelUI"+                               , "BasicListUI"+                               , "BasicLookAndFeel"+                               , "BasicMenuBarUI"+                               , "BasicMenuItemUI"+                               , "BasicMenuUI"+                               , "BasicOptionPaneUI"+                               , "BasicOptionPaneUI.ButtonAreaLayout"+                               , "BasicPanelUI"+                               , "BasicPasswordFieldUI"+                               , "BasicPermission"+                               , "BasicPopupMenuSeparatorUI"+                               , "BasicPopupMenuUI"+                               , "BasicProgressBarUI"+                               , "BasicRadioButtonMenuItemUI"+                               , "BasicRadioButtonUI"+                               , "BasicRootPaneUI"+                               , "BasicScrollBarUI"+                               , "BasicScrollPaneUI"+                               , "BasicSeparatorUI"+                               , "BasicSliderUI"+                               , "BasicSpinnerUI"+                               , "BasicSplitPaneDivider"+                               , "BasicSplitPaneUI"+                               , "BasicStroke"+                               , "BasicTabbedPaneUI"+                               , "BasicTableHeaderUI"+                               , "BasicTableUI"+                               , "BasicTextAreaUI"+                               , "BasicTextFieldUI"+                               , "BasicTextPaneUI"+                               , "BasicTextUI"+                               , "BasicTextUI.BasicCaret"+                               , "BasicTextUI.BasicHighlighter"+                               , "BasicToggleButtonUI"+                               , "BasicToolBarSeparatorUI"+                               , "BasicToolBarUI"+                               , "BasicToolTipUI"+                               , "BasicTreeUI"+                               , "BasicViewportUI"+                               , "BatchUpdateException"+                               , "BeanContext"+                               , "BeanContextChild"+                               , "BeanContextChildComponentProxy"+                               , "BeanContextChildSupport"+                               , "BeanContextContainerProxy"+                               , "BeanContextEvent"+                               , "BeanContextMembershipEvent"+                               , "BeanContextMembershipListener"+                               , "BeanContextProxy"+                               , "BeanContextServiceAvailableEvent"+                               , "BeanContextServiceProvider"+                               , "BeanContextServiceProviderBeanInfo"+                               , "BeanContextServiceRevokedEvent"+                               , "BeanContextServiceRevokedListener"+                               , "BeanContextServices"+                               , "BeanContextServicesListener"+                               , "BeanContextServicesSupport"+                               , "BeanContextServicesSupport.BCSSServiceProvider"+                               , "BeanContextSupport"+                               , "BeanContextSupport.BCSIterator"+                               , "BeanDescriptor"+                               , "BeanInfo"+                               , "Beans"+                               , "BevelBorder"+                               , "Bidi"+                               , "BigDecimal"+                               , "BigInteger"+                               , "BinaryRefAddr"+                               , "BindException"+                               , "Binder"+                               , "Binding"+                               , "BindingHelper"+                               , "BindingHolder"+                               , "BindingIterator"+                               , "BindingIteratorHelper"+                               , "BindingIteratorHolder"+                               , "BindingIteratorOperations"+                               , "BindingIteratorPOA"+                               , "BindingListHelper"+                               , "BindingListHolder"+                               , "BindingProvider"+                               , "BindingType"+                               , "BindingTypeHelper"+                               , "BindingTypeHolder"+                               , "Bindings"+                               , "BitSet"+                               , "Blob"+                               , "BlockView"+                               , "BlockingDeque"+                               , "BlockingQueue"+                               , "Book"+                               , "Boolean"+                               , "BooleanControl"+                               , "BooleanControl.Type"+                               , "BooleanHolder"+                               , "BooleanSeqHelper"+                               , "BooleanSeqHolder"+                               , "Border"+                               , "BorderFactory"+                               , "BorderLayout"+                               , "BorderUIResource"+                               , "BorderUIResource.BevelBorderUIResource"+                               , "BorderUIResource.CompoundBorderUIResource"+                               , "BorderUIResource.EmptyBorderUIResource"+                               , "BorderUIResource.EtchedBorderUIResource"+                               , "BorderUIResource.LineBorderUIResource"+                               , "BorderUIResource.MatteBorderUIResource"+                               , "BorderUIResource.TitledBorderUIResource"+                               , "BoundedRangeModel"+                               , "Bounds"+                               , "Box"+                               , "Box.Filler"+                               , "BoxLayout"+                               , "BoxView"+                               , "BoxedValueHelper"+                               , "BreakIterator"+                               , "BreakIteratorProvider"+                               , "BrokenBarrierException"+                               , "Buffer"+                               , "BufferCapabilities"+                               , "BufferCapabilities.FlipContents"+                               , "BufferOverflowException"+                               , "BufferStrategy"+                               , "BufferUnderflowException"+                               , "BufferedImage"+                               , "BufferedImageFilter"+                               , "BufferedImageOp"+                               , "BufferedInputStream"+                               , "BufferedOutputStream"+                               , "BufferedReader"+                               , "BufferedWriter"+                               , "Button"+                               , "ButtonGroup"+                               , "ButtonModel"+                               , "ButtonUI"+                               , "Byte"+                               , "ByteArrayInputStream"+                               , "ByteArrayOutputStream"+                               , "ByteBuffer"+                               , "ByteChannel"+                               , "ByteHolder"+                               , "ByteLookupTable"+                               , "ByteOrder"+                               , "C14NMethodParameterSpec"+                               , "CDATASection"+                               , "CMMException"+                               , "CODESET_INCOMPATIBLE"+                               , "COMM_FAILURE"+                               , "CRC32"+                               , "CRL"+                               , "CRLException"+                               , "CRLSelector"+                               , "CSS"+                               , "CSS.Attribute"+                               , "CTX_RESTRICT_SCOPE"+                               , "CacheRequest"+                               , "CacheResponse"+                               , "CachedRowSet"+                               , "Calendar"+                               , "Callable"+                               , "CallableStatement"+                               , "Callback"+                               , "CallbackHandler"+                               , "CancelablePrintJob"+                               , "CancellationException"+                               , "CancelledKeyException"+                               , "CannotProceed"+                               , "CannotProceedException"+                               , "CannotProceedHelper"+                               , "CannotProceedHolder"+                               , "CannotRedoException"+                               , "CannotUndoException"+                               , "CanonicalizationMethod"+                               , "Canvas"+                               , "CardLayout"+                               , "Caret"+                               , "CaretEvent"+                               , "CaretListener"+                               , "CellEditor"+                               , "CellEditorListener"+                               , "CellRendererPane"+                               , "CertPath"+                               , "CertPath.CertPathRep"+                               , "CertPathBuilder"+                               , "CertPathBuilderException"+                               , "CertPathBuilderResult"+                               , "CertPathBuilderSpi"+                               , "CertPathParameters"+                               , "CertPathTrustManagerParameters"+                               , "CertPathValidator"+                               , "CertPathValidatorException"+                               , "CertPathValidatorResult"+                               , "CertPathValidatorSpi"+                               , "CertSelector"+                               , "CertStore"+                               , "CertStoreException"+                               , "CertStoreParameters"+                               , "CertStoreSpi"+                               , "Certificate"+                               , "Certificate.CertificateRep"+                               , "CertificateEncodingException"+                               , "CertificateException"+                               , "CertificateExpiredException"+                               , "CertificateFactory"+                               , "CertificateFactorySpi"+                               , "CertificateNotYetValidException"+                               , "CertificateParsingException"+                               , "ChangeEvent"+                               , "ChangeListener"+                               , "ChangedCharSetException"+                               , "Channel"+                               , "ChannelBinding"+                               , "Channels"+                               , "CharArrayReader"+                               , "CharArrayWriter"+                               , "CharBuffer"+                               , "CharConversionException"+                               , "CharHolder"+                               , "CharSeqHelper"+                               , "CharSeqHolder"+                               , "CharSequence"+                               , "Character"+                               , "Character.Subset"+                               , "Character.UnicodeBlock"+                               , "CharacterCodingException"+                               , "CharacterData"+                               , "CharacterIterator"+                               , "Characters"+                               , "Charset"+                               , "CharsetDecoder"+                               , "CharsetEncoder"+                               , "CharsetProvider"+                               , "Checkbox"+                               , "CheckboxGroup"+                               , "CheckboxMenuItem"+                               , "CheckedInputStream"+                               , "CheckedOutputStream"+                               , "Checksum"+                               , "Choice"+                               , "ChoiceCallback"+                               , "ChoiceFormat"+                               , "Chromaticity"+                               , "Cipher"+                               , "CipherInputStream"+                               , "CipherOutputStream"+                               , "CipherSpi"+                               , "Class"+                               , "ClassCastException"+                               , "ClassCircularityError"+                               , "ClassDefinition"+                               , "ClassDesc"+                               , "ClassFileTransformer"+                               , "ClassFormatError"+                               , "ClassLoader"+                               , "ClassLoaderRepository"+                               , "ClassLoadingMXBean"+                               , "ClassNotFoundException"+                               , "ClientInfoStatus"+                               , "ClientRequestInfo"+                               , "ClientRequestInfoOperations"+                               , "ClientRequestInterceptor"+                               , "ClientRequestInterceptorOperations"+                               , "Clip"+                               , "Clipboard"+                               , "ClipboardOwner"+                               , "Clob"+                               , "CloneNotSupportedException"+                               , "Cloneable"+                               , "Closeable"+                               , "ClosedByInterruptException"+                               , "ClosedChannelException"+                               , "ClosedSelectorException"+                               , "CodeSets"+                               , "CodeSigner"+                               , "CodeSource"+                               , "Codec"+                               , "CodecFactory"+                               , "CodecFactoryHelper"+                               , "CodecFactoryOperations"+                               , "CodecOperations"+                               , "CoderMalfunctionError"+                               , "CoderResult"+                               , "CodingErrorAction"+                               , "CollapsedStringAdapter"+                               , "CollationElementIterator"+                               , "CollationKey"+                               , "Collator"+                               , "CollatorProvider"+                               , "Collection"+                               , "CollectionCertStoreParameters"+                               , "Collections"+                               , "Color"+                               , "ColorChooserComponentFactory"+                               , "ColorChooserUI"+                               , "ColorConvertOp"+                               , "ColorModel"+                               , "ColorSelectionModel"+                               , "ColorSpace"+                               , "ColorSupported"+                               , "ColorType"+                               , "ColorUIResource"+                               , "ComboBoxEditor"+                               , "ComboBoxModel"+                               , "ComboBoxUI"+                               , "ComboPopup"+                               , "CommandInfo"+                               , "CommandMap"+                               , "CommandObject"+                               , "Comment"+                               , "CommonDataSource"+                               , "CommunicationException"+                               , "Comparable"+                               , "Comparator"+                               , "Compilable"+                               , "CompilationMXBean"+                               , "CompiledScript"+                               , "Compiler"+                               , "Completion"+                               , "CompletionService"+                               , "CompletionStatus"+                               , "CompletionStatusHelper"+                               , "Completions"+                               , "Component"+                               , "ComponentAdapter"+                               , "ComponentColorModel"+                               , "ComponentEvent"+                               , "ComponentIdHelper"+                               , "ComponentInputMap"+                               , "ComponentInputMapUIResource"+                               , "ComponentListener"+                               , "ComponentOrientation"+                               , "ComponentSampleModel"+                               , "ComponentUI"+                               , "ComponentView"+                               , "Composite"+                               , "CompositeContext"+                               , "CompositeData"+                               , "CompositeDataInvocationHandler"+                               , "CompositeDataSupport"+                               , "CompositeDataView"+                               , "CompositeName"+                               , "CompositeType"+                               , "CompositeView"+                               , "CompoundBorder"+                               , "CompoundControl"+                               , "CompoundControl.Type"+                               , "CompoundEdit"+                               , "CompoundName"+                               , "Compression"+                               , "ConcurrentHashMap"+                               , "ConcurrentLinkedQueue"+                               , "ConcurrentMap"+                               , "ConcurrentModificationException"+                               , "ConcurrentNavigableMap"+                               , "ConcurrentSkipListMap"+                               , "ConcurrentSkipListSet"+                               , "Condition"+                               , "Configuration"+                               , "ConfigurationException"+                               , "ConfigurationSpi"+                               , "ConfirmationCallback"+                               , "ConnectException"+                               , "ConnectIOException"+                               , "Connection"+                               , "ConnectionEvent"+                               , "ConnectionEventListener"+                               , "ConnectionPendingException"+                               , "ConnectionPoolDataSource"+                               , "Console"+                               , "ConsoleHandler"+                               , "Constructor"+                               , "ConstructorProperties"+                               , "Container"+                               , "ContainerAdapter"+                               , "ContainerEvent"+                               , "ContainerListener"+                               , "ContainerOrderFocusTraversalPolicy"+                               , "ContentHandler"+                               , "ContentHandlerFactory"+                               , "ContentModel"+                               , "Context"+                               , "ContextList"+                               , "ContextNotEmptyException"+                               , "ContextualRenderedImageFactory"+                               , "Control"+                               , "Control.Type"+                               , "ControlFactory"+                               , "ControllerEventListener"+                               , "ConvolveOp"+                               , "CookieHandler"+                               , "CookieHolder"+                               , "CookieManager"+                               , "CookiePolicy"+                               , "CookieStore"+                               , "Copies"+                               , "CopiesSupported"+                               , "CopyOnWriteArrayList"+                               , "CopyOnWriteArraySet"+                               , "CountDownLatch"+                               , "CounterMonitor"+                               , "CounterMonitorMBean"+                               , "CredentialException"+                               , "CredentialExpiredException"+                               , "CredentialNotFoundException"+                               , "CropImageFilter"+                               , "CubicCurve2D"+                               , "CubicCurve2D.Double"+                               , "CubicCurve2D.Float"+                               , "Currency"+                               , "CurrencyNameProvider"+                               , "Current"+                               , "CurrentHelper"+                               , "CurrentHolder"+                               , "CurrentOperations"+                               , "Cursor"+                               , "CustomMarshal"+                               , "CustomValue"+                               , "Customizer"+                               , "CyclicBarrier"+                               , "DATA_CONVERSION"+                               , "DESKeySpec"+                               , "DESedeKeySpec"+                               , "DGC"+                               , "DHGenParameterSpec"+                               , "DHKey"+                               , "DHParameterSpec"+                               , "DHPrivateKey"+                               , "DHPrivateKeySpec"+                               , "DHPublicKey"+                               , "DHPublicKeySpec"+                               , "DISCARDING"+                               , "DOMConfiguration"+                               , "DOMCryptoContext"+                               , "DOMError"+                               , "DOMErrorHandler"+                               , "DOMException"+                               , "DOMImplementation"+                               , "DOMImplementationLS"+                               , "DOMImplementationList"+                               , "DOMImplementationRegistry"+                               , "DOMImplementationSource"+                               , "DOMLocator"+                               , "DOMResult"+                               , "DOMSignContext"+                               , "DOMSource"+                               , "DOMStringList"+                               , "DOMStructure"+                               , "DOMURIReference"+                               , "DOMValidateContext"+                               , "DSAKey"+                               , "DSAKeyPairGenerator"+                               , "DSAParameterSpec"+                               , "DSAParams"+                               , "DSAPrivateKey"+                               , "DSAPrivateKeySpec"+                               , "DSAPublicKey"+                               , "DSAPublicKeySpec"+                               , "DTD"+                               , "DTDConstants"+                               , "DTDHandler"+                               , "Data"+                               , "DataBuffer"+                               , "DataBufferByte"+                               , "DataBufferDouble"+                               , "DataBufferFloat"+                               , "DataBufferInt"+                               , "DataBufferShort"+                               , "DataBufferUShort"+                               , "DataContentHandler"+                               , "DataContentHandlerFactory"+                               , "DataFlavor"+                               , "DataFormatException"+                               , "DataHandler"+                               , "DataInput"+                               , "DataInputStream"+                               , "DataLine"+                               , "DataLine.Info"+                               , "DataOutput"+                               , "DataOutputStream"+                               , "DataSource"+                               , "DataTruncation"+                               , "DatabaseMetaData"+                               , "DatagramChannel"+                               , "DatagramPacket"+                               , "DatagramSocket"+                               , "DatagramSocketImpl"+                               , "DatagramSocketImplFactory"+                               , "DatatypeConfigurationException"+                               , "DatatypeConstants"+                               , "DatatypeConstants.Field"+                               , "DatatypeConverter"+                               , "DatatypeConverterInterface"+                               , "DatatypeFactory"+                               , "Date"+                               , "DateFormat"+                               , "DateFormat.Field"+                               , "DateFormatProvider"+                               , "DateFormatSymbols"+                               , "DateFormatSymbolsProvider"+                               , "DateFormatter"+                               , "DateTimeAtCompleted"+                               , "DateTimeAtCreation"+                               , "DateTimeAtProcessing"+                               , "DateTimeSyntax"+                               , "DebugGraphics"+                               , "DecimalFormat"+                               , "DecimalFormatSymbols"+                               , "DecimalFormatSymbolsProvider"+                               , "DeclHandler"+                               , "DeclaredType"+                               , "DefaultBoundedRangeModel"+                               , "DefaultButtonModel"+                               , "DefaultCaret"+                               , "DefaultCellEditor"+                               , "DefaultColorSelectionModel"+                               , "DefaultComboBoxModel"+                               , "DefaultDesktopManager"+                               , "DefaultEditorKit"+                               , "DefaultEditorKit.BeepAction"+                               , "DefaultEditorKit.CopyAction"+                               , "DefaultEditorKit.CutAction"+                               , "DefaultEditorKit.DefaultKeyTypedAction"+                               , "DefaultEditorKit.InsertBreakAction"+                               , "DefaultEditorKit.InsertContentAction"+                               , "DefaultEditorKit.InsertTabAction"+                               , "DefaultEditorKit.PasteAction"+                               , "DefaultFocusManager"+                               , "DefaultFocusTraversalPolicy"+                               , "DefaultFormatter"+                               , "DefaultFormatterFactory"+                               , "DefaultHandler"+                               , "DefaultHandler2"+                               , "DefaultHighlighter"+                               , "DefaultHighlighter.DefaultHighlightPainter"+                               , "DefaultKeyboardFocusManager"+                               , "DefaultListCellRenderer"+                               , "DefaultListCellRenderer.UIResource"+                               , "DefaultListModel"+                               , "DefaultListSelectionModel"+                               , "DefaultLoaderRepository"+                               , "DefaultMenuLayout"+                               , "DefaultMetalTheme"+                               , "DefaultMutableTreeNode"+                               , "DefaultPersistenceDelegate"+                               , "DefaultRowSorter"+                               , "DefaultSingleSelectionModel"+                               , "DefaultStyledDocument"+                               , "DefaultStyledDocument.AttributeUndoableEdit"+                               , "DefaultStyledDocument.ElementSpec"+                               , "DefaultTableCellRenderer"+                               , "DefaultTableCellRenderer.UIResource"+                               , "DefaultTableColumnModel"+                               , "DefaultTableModel"+                               , "DefaultTextUI"+                               , "DefaultTreeCellEditor"+                               , "DefaultTreeCellRenderer"+                               , "DefaultTreeModel"+                               , "DefaultTreeSelectionModel"+                               , "DefaultValidationEventHandler"+                               , "DefinitionKind"+                               , "DefinitionKindHelper"+                               , "Deflater"+                               , "DeflaterInputStream"+                               , "DeflaterOutputStream"+                               , "DelayQueue"+                               , "Delayed"+                               , "Delegate"+                               , "DelegationPermission"+                               , "Deprecated"+                               , "Deque"+                               , "Descriptor"+                               , "DescriptorAccess"+                               , "DescriptorKey"+                               , "DescriptorRead"+                               , "DescriptorSupport"+                               , "DesignMode"+                               , "Desktop"+                               , "DesktopIconUI"+                               , "DesktopManager"+                               , "DesktopPaneUI"+                               , "Destination"+                               , "DestroyFailedException"+                               , "Destroyable"+                               , "Detail"+                               , "DetailEntry"+                               , "Diagnostic"+                               , "DiagnosticCollector"+                               , "DiagnosticListener"+                               , "Dialog"+                               , "Dictionary"+                               , "DigestException"+                               , "DigestInputStream"+                               , "DigestMethod"+                               , "DigestMethodParameterSpec"+                               , "DigestOutputStream"+                               , "Dimension"+                               , "Dimension2D"+                               , "DimensionUIResource"+                               , "DirContext"+                               , "DirObjectFactory"+                               , "DirStateFactory"+                               , "DirStateFactory.Result"+                               , "DirectColorModel"+                               , "DirectoryManager"+                               , "Dispatch"+                               , "DisplayMode"+                               , "DnDConstants"+                               , "Doc"+                               , "DocAttribute"+                               , "DocAttributeSet"+                               , "DocFlavor"+                               , "DocFlavor.BYTE_ARRAY"+                               , "DocFlavor.CHAR_ARRAY"+                               , "DocFlavor.INPUT_STREAM"+                               , "DocFlavor.READER"+                               , "DocFlavor.SERVICE_FORMATTED"+                               , "DocFlavor.STRING"+                               , "DocFlavor.URL"+                               , "DocPrintJob"+                               , "Document"+                               , "DocumentBuilder"+                               , "DocumentBuilderFactory"+                               , "DocumentEvent"+                               , "DocumentEvent.ElementChange"+                               , "DocumentEvent.EventType"+                               , "DocumentFilter"+                               , "DocumentFilter.FilterBypass"+                               , "DocumentFragment"+                               , "DocumentHandler"+                               , "DocumentListener"+                               , "DocumentName"+                               , "DocumentParser"+                               , "DocumentType"+                               , "Documented"+                               , "DomHandler"+                               , "DomainCombiner"+                               , "DomainManager"+                               , "DomainManagerOperations"+                               , "Double"+                               , "DoubleBuffer"+                               , "DoubleHolder"+                               , "DoubleSeqHelper"+                               , "DoubleSeqHolder"+                               , "DragGestureEvent"+                               , "DragGestureListener"+                               , "DragGestureRecognizer"+                               , "DragSource"+                               , "DragSourceAdapter"+                               , "DragSourceContext"+                               , "DragSourceDragEvent"+                               , "DragSourceDropEvent"+                               , "DragSourceEvent"+                               , "DragSourceListener"+                               , "DragSourceMotionListener"+                               , "Driver"+                               , "DriverManager"+                               , "DriverPropertyInfo"+                               , "DropMode"+                               , "DropTarget"+                               , "DropTarget.DropTargetAutoScroller"+                               , "DropTargetAdapter"+                               , "DropTargetContext"+                               , "DropTargetDragEvent"+                               , "DropTargetDropEvent"+                               , "DropTargetEvent"+                               , "DropTargetListener"+                               , "DuplicateFormatFlagsException"+                               , "DuplicateName"+                               , "DuplicateNameHelper"+                               , "Duration"+                               , "DynAny"+                               , "DynAnyFactory"+                               , "DynAnyFactoryHelper"+                               , "DynAnyFactoryOperations"+                               , "DynAnyHelper"+                               , "DynAnyOperations"+                               , "DynAnySeqHelper"+                               , "DynArray"+                               , "DynArrayHelper"+                               , "DynArrayOperations"+                               , "DynEnum"+                               , "DynEnumHelper"+                               , "DynEnumOperations"+                               , "DynFixed"+                               , "DynFixedHelper"+                               , "DynFixedOperations"+                               , "DynSequence"+                               , "DynSequenceHelper"+                               , "DynSequenceOperations"+                               , "DynStruct"+                               , "DynStructHelper"+                               , "DynStructOperations"+                               , "DynUnion"+                               , "DynUnionHelper"+                               , "DynUnionOperations"+                               , "DynValue"+                               , "DynValueBox"+                               , "DynValueBoxOperations"+                               , "DynValueCommon"+                               , "DynValueCommonOperations"+                               , "DynValueHelper"+                               , "DynValueOperations"+                               , "DynamicImplementation"+                               , "DynamicMBean"+                               , "ECField"+                               , "ECFieldF2m"+                               , "ECFieldFp"+                               , "ECGenParameterSpec"+                               , "ECKey"+                               , "ECParameterSpec"+                               , "ECPoint"+                               , "ECPrivateKey"+                               , "ECPrivateKeySpec"+                               , "ECPublicKey"+                               , "ECPublicKeySpec"+                               , "ENCODING_CDR_ENCAPS"+                               , "EOFException"+                               , "EditorKit"+                               , "Element"+                               , "ElementFilter"+                               , "ElementIterator"+                               , "ElementKind"+                               , "ElementKindVisitor6"+                               , "ElementScanner6"+                               , "ElementType"+                               , "ElementVisitor"+                               , "Elements"+                               , "Ellipse2D"+                               , "Ellipse2D.Double"+                               , "Ellipse2D.Float"+                               , "EllipticCurve"+                               , "EmptyBorder"+                               , "EmptyStackException"+                               , "EncodedKeySpec"+                               , "Encoder"+                               , "Encoding"+                               , "EncryptedPrivateKeyInfo"+                               , "EndDocument"+                               , "EndElement"+                               , "Endpoint"+                               , "Entity"+                               , "EntityDeclaration"+                               , "EntityReference"+                               , "EntityResolver"+                               , "EntityResolver2"+                               , "Enum"+                               , "EnumConstantNotPresentException"+                               , "EnumControl"+                               , "EnumControl.Type"+                               , "EnumMap"+                               , "EnumSet"+                               , "EnumSyntax"+                               , "Enumeration"+                               , "Environment"+                               , "Error"+                               , "ErrorHandler"+                               , "ErrorListener"+                               , "ErrorManager"+                               , "ErrorType"+                               , "EtchedBorder"+                               , "Event"+                               , "EventContext"+                               , "EventDirContext"+                               , "EventException"+                               , "EventFilter"+                               , "EventHandler"+                               , "EventListener"+                               , "EventListenerList"+                               , "EventListenerProxy"+                               , "EventObject"+                               , "EventQueue"+                               , "EventReaderDelegate"+                               , "EventSetDescriptor"+                               , "EventTarget"+                               , "ExcC14NParameterSpec"+                               , "Exception"+                               , "ExceptionDetailMessage"+                               , "ExceptionInInitializerError"+                               , "ExceptionList"+                               , "ExceptionListener"+                               , "Exchanger"+                               , "ExecutableElement"+                               , "ExecutableType"+                               , "ExecutionException"+                               , "Executor"+                               , "ExecutorCompletionService"+                               , "ExecutorService"+                               , "Executors"+                               , "ExemptionMechanism"+                               , "ExemptionMechanismException"+                               , "ExemptionMechanismSpi"+                               , "ExpandVetoException"+                               , "ExportException"+                               , "Expression"+                               , "ExtendedRequest"+                               , "ExtendedResponse"+                               , "Externalizable"+                               , "FREE_MEM"+                               , "FactoryConfigurationError"+                               , "FailedLoginException"+                               , "FeatureDescriptor"+                               , "Fidelity"+                               , "Field"+                               , "FieldNameHelper"+                               , "FieldPosition"+                               , "FieldView"+                               , "File"+                               , "FileCacheImageInputStream"+                               , "FileCacheImageOutputStream"+                               , "FileChannel"+                               , "FileChannel.MapMode"+                               , "FileChooserUI"+                               , "FileDataSource"+                               , "FileDescriptor"+                               , "FileDialog"+                               , "FileFilter"+                               , "FileHandler"+                               , "FileImageInputStream"+                               , "FileImageOutputStream"+                               , "FileInputStream"+                               , "FileLock"+                               , "FileLockInterruptionException"+                               , "FileNameExtensionFilter"+                               , "FileNameMap"+                               , "FileNotFoundException"+                               , "FileObject"+                               , "FileOutputStream"+                               , "FilePermission"+                               , "FileReader"+                               , "FileSystemView"+                               , "FileTypeMap"+                               , "FileView"+                               , "FileWriter"+                               , "FilenameFilter"+                               , "Filer"+                               , "FilerException"+                               , "Filter"+                               , "FilterInputStream"+                               , "FilterOutputStream"+                               , "FilterReader"+                               , "FilterWriter"+                               , "FilteredImageSource"+                               , "FilteredRowSet"+                               , "Finishings"+                               , "FixedHeightLayoutCache"+                               , "FixedHolder"+                               , "FlatteningPathIterator"+                               , "FlavorEvent"+                               , "FlavorException"+                               , "FlavorListener"+                               , "FlavorMap"+                               , "FlavorTable"+                               , "Float"+                               , "FloatBuffer"+                               , "FloatControl"+                               , "FloatControl.Type"+                               , "FloatHolder"+                               , "FloatSeqHelper"+                               , "FloatSeqHolder"+                               , "FlowLayout"+                               , "FlowView"+                               , "FlowView.FlowStrategy"+                               , "Flushable"+                               , "FocusAdapter"+                               , "FocusEvent"+                               , "FocusListener"+                               , "FocusManager"+                               , "FocusTraversalPolicy"+                               , "Font"+                               , "FontFormatException"+                               , "FontMetrics"+                               , "FontRenderContext"+                               , "FontUIResource"+                               , "FormSubmitEvent"+                               , "FormSubmitEvent.MethodType"+                               , "FormView"+                               , "Format"+                               , "Format.Field"+                               , "FormatConversionProvider"+                               , "FormatFlagsConversionMismatchException"+                               , "FormatMismatch"+                               , "FormatMismatchHelper"+                               , "Formattable"+                               , "FormattableFlags"+                               , "Formatter"+                               , "FormatterClosedException"+                               , "ForwardRequest"+                               , "ForwardRequestHelper"+                               , "ForwardingFileObject"+                               , "ForwardingJavaFileManager"+                               , "ForwardingJavaFileObject"+                               , "Frame"+                               , "Future"+                               , "FutureTask"+                               , "GSSContext"+                               , "GSSCredential"+                               , "GSSException"+                               , "GSSManager"+                               , "GSSName"+                               , "GZIPInputStream"+                               , "GZIPOutputStream"+                               , "GapContent"+                               , "GarbageCollectorMXBean"+                               , "GatheringByteChannel"+                               , "GaugeMonitor"+                               , "GaugeMonitorMBean"+                               , "GeneralPath"+                               , "GeneralSecurityException"+                               , "Generated"+                               , "GenericArrayType"+                               , "GenericDeclaration"+                               , "GenericSignatureFormatError"+                               , "GlyphJustificationInfo"+                               , "GlyphMetrics"+                               , "GlyphVector"+                               , "GlyphView"+                               , "GlyphView.GlyphPainter"+                               , "GradientPaint"+                               , "GraphicAttribute"+                               , "Graphics"+                               , "Graphics2D"+                               , "GraphicsConfigTemplate"+                               , "GraphicsConfiguration"+                               , "GraphicsDevice"+                               , "GraphicsEnvironment"+                               , "GrayFilter"+                               , "GregorianCalendar"+                               , "GridBagConstraints"+                               , "GridBagLayout"+                               , "GridBagLayoutInfo"+                               , "GridLayout"+                               , "Group"+                               , "GroupLayout"+                               , "Guard"+                               , "GuardedObject"+                               , "HMACParameterSpec"+                               , "HOLDING"+                               , "HTML"+                               , "HTML.Attribute"+                               , "HTML.Tag"+                               , "HTML.UnknownTag"+                               , "HTMLDocument"+                               , "HTMLDocument.Iterator"+                               , "HTMLEditorKit"+                               , "HTMLEditorKit.HTMLFactory"+                               , "HTMLEditorKit.HTMLTextAction"+                               , "HTMLEditorKit.InsertHTMLTextAction"+                               , "HTMLEditorKit.LinkController"+                               , "HTMLEditorKit.Parser"+                               , "HTMLEditorKit.ParserCallback"+                               , "HTMLFrameHyperlinkEvent"+                               , "HTMLWriter"+                               , "HTTPBinding"+                               , "HTTPException"+                               , "Handler"+                               , "HandlerBase"+                               , "HandlerChain"+                               , "HandlerResolver"+                               , "HandshakeCompletedEvent"+                               , "HandshakeCompletedListener"+                               , "HasControls"+                               , "HashAttributeSet"+                               , "HashDocAttributeSet"+                               , "HashMap"+                               , "HashPrintJobAttributeSet"+                               , "HashPrintRequestAttributeSet"+                               , "HashPrintServiceAttributeSet"+                               , "HashSet"+                               , "Hashtable"+                               , "HeadlessException"+                               , "HexBinaryAdapter"+                               , "HierarchyBoundsAdapter"+                               , "HierarchyBoundsListener"+                               , "HierarchyEvent"+                               , "HierarchyListener"+                               , "Highlighter"+                               , "Highlighter.Highlight"+                               , "Highlighter.HighlightPainter"+                               , "Holder"+                               , "HostnameVerifier"+                               , "HttpCookie"+                               , "HttpRetryException"+                               , "HttpURLConnection"+                               , "HttpsURLConnection"+                               , "HyperlinkEvent"+                               , "HyperlinkEvent.EventType"+                               , "HyperlinkListener"+                               , "ICC_ColorSpace"+                               , "ICC_Profile"+                               , "ICC_ProfileGray"+                               , "ICC_ProfileRGB"+                               , "IDLEntity"+                               , "IDLType"+                               , "IDLTypeHelper"+                               , "IDLTypeOperations"+                               , "IDN"+                               , "ID_ASSIGNMENT_POLICY_ID"+                               , "ID_UNIQUENESS_POLICY_ID"+                               , "IIOByteBuffer"+                               , "IIOException"+                               , "IIOImage"+                               , "IIOInvalidTreeException"+                               , "IIOMetadata"+                               , "IIOMetadataController"+                               , "IIOMetadataFormat"+                               , "IIOMetadataFormatImpl"+                               , "IIOMetadataNode"+                               , "IIOParam"+                               , "IIOParamController"+                               , "IIOReadProgressListener"+                               , "IIOReadUpdateListener"+                               , "IIOReadWarningListener"+                               , "IIORegistry"+                               , "IIOServiceProvider"+                               , "IIOWriteProgressListener"+                               , "IIOWriteWarningListener"+                               , "IMPLICIT_ACTIVATION_POLICY_ID"+                               , "IMP_LIMIT"+                               , "INACTIVE"+                               , "INITIALIZE"+                               , "INTERNAL"+                               , "INTF_REPOS"+                               , "INVALID_ACTIVITY"+                               , "INVALID_TRANSACTION"+                               , "INV_FLAG"+                               , "INV_IDENT"+                               , "INV_OBJREF"+                               , "INV_POLICY"+                               , "IOError"+                               , "IOException"+                               , "IOR"+                               , "IORHelper"+                               , "IORHolder"+                               , "IORInfo"+                               , "IORInfoOperations"+                               , "IORInterceptor"+                               , "IORInterceptorOperations"+                               , "IORInterceptor_3_0"+                               , "IORInterceptor_3_0Helper"+                               , "IORInterceptor_3_0Holder"+                               , "IORInterceptor_3_0Operations"+                               , "IRObject"+                               , "IRObjectOperations"+                               , "Icon"+                               , "IconUIResource"+                               , "IconView"+                               , "IdAssignmentPolicy"+                               , "IdAssignmentPolicyOperations"+                               , "IdAssignmentPolicyValue"+                               , "IdUniquenessPolicy"+                               , "IdUniquenessPolicyOperations"+                               , "IdUniquenessPolicyValue"+                               , "IdentifierHelper"+                               , "Identity"+                               , "IdentityHashMap"+                               , "IdentityScope"+                               , "IllegalAccessError"+                               , "IllegalAccessException"+                               , "IllegalArgumentException"+                               , "IllegalBlockSizeException"+                               , "IllegalBlockingModeException"+                               , "IllegalCharsetNameException"+                               , "IllegalClassFormatException"+                               , "IllegalComponentStateException"+                               , "IllegalFormatCodePointException"+                               , "IllegalFormatConversionException"+                               , "IllegalFormatException"+                               , "IllegalFormatFlagsException"+                               , "IllegalFormatPrecisionException"+                               , "IllegalFormatWidthException"+                               , "IllegalMonitorStateException"+                               , "IllegalPathStateException"+                               , "IllegalSelectorException"+                               , "IllegalStateException"+                               , "IllegalThreadStateException"+                               , "Image"+                               , "ImageCapabilities"+                               , "ImageConsumer"+                               , "ImageFilter"+                               , "ImageGraphicAttribute"+                               , "ImageIO"+                               , "ImageIcon"+                               , "ImageInputStream"+                               , "ImageInputStreamImpl"+                               , "ImageInputStreamSpi"+                               , "ImageObserver"+                               , "ImageOutputStream"+                               , "ImageOutputStreamImpl"+                               , "ImageOutputStreamSpi"+                               , "ImageProducer"+                               , "ImageReadParam"+                               , "ImageReader"+                               , "ImageReaderSpi"+                               , "ImageReaderWriterSpi"+                               , "ImageTranscoder"+                               , "ImageTranscoderSpi"+                               , "ImageTypeSpecifier"+                               , "ImageView"+                               , "ImageWriteParam"+                               , "ImageWriter"+                               , "ImageWriterSpi"+                               , "ImagingOpException"+                               , "ImmutableDescriptor"+                               , "ImplicitActivationPolicy"+                               , "ImplicitActivationPolicyOperations"+                               , "ImplicitActivationPolicyValue"+                               , "IncompatibleClassChangeError"+                               , "IncompleteAnnotationException"+                               , "InconsistentTypeCode"+                               , "InconsistentTypeCodeHelper"+                               , "IndexColorModel"+                               , "IndexOutOfBoundsException"+                               , "IndexedPropertyChangeEvent"+                               , "IndexedPropertyDescriptor"+                               , "IndirectionException"+                               , "Inet4Address"+                               , "Inet6Address"+                               , "InetAddress"+                               , "InetSocketAddress"+                               , "Inflater"+                               , "InflaterInputStream"+                               , "InflaterOutputStream"+                               , "InheritableThreadLocal"+                               , "Inherited"+                               , "InitParam"+                               , "InitialContext"+                               , "InitialContextFactory"+                               , "InitialContextFactoryBuilder"+                               , "InitialDirContext"+                               , "InitialLdapContext"+                               , "InlineView"+                               , "InputContext"+                               , "InputEvent"+                               , "InputMap"+                               , "InputMapUIResource"+                               , "InputMethod"+                               , "InputMethodContext"+                               , "InputMethodDescriptor"+                               , "InputMethodEvent"+                               , "InputMethodHighlight"+                               , "InputMethodListener"+                               , "InputMethodRequests"+                               , "InputMismatchException"+                               , "InputSource"+                               , "InputStream"+                               , "InputStreamReader"+                               , "InputSubset"+                               , "InputVerifier"+                               , "Insets"+                               , "InsetsUIResource"+                               , "InstanceAlreadyExistsException"+                               , "InstanceNotFoundException"+                               , "InstantiationError"+                               , "InstantiationException"+                               , "Instrument"+                               , "Instrumentation"+                               , "InsufficientResourcesException"+                               , "IntBuffer"+                               , "IntHolder"+                               , "Integer"+                               , "IntegerSyntax"+                               , "Interceptor"+                               , "InterceptorOperations"+                               , "InterfaceAddress"+                               , "InternalError"+                               , "InternalFrameAdapter"+                               , "InternalFrameEvent"+                               , "InternalFrameFocusTraversalPolicy"+                               , "InternalFrameListener"+                               , "InternalFrameUI"+                               , "InternationalFormatter"+                               , "InterruptedException"+                               , "InterruptedIOException"+                               , "InterruptedNamingException"+                               , "InterruptibleChannel"+                               , "IntrospectionException"+                               , "Introspector"+                               , "Invalid"+                               , "InvalidActivityException"+                               , "InvalidAddress"+                               , "InvalidAddressHelper"+                               , "InvalidAddressHolder"+                               , "InvalidAlgorithmParameterException"+                               , "InvalidApplicationException"+                               , "InvalidAttributeIdentifierException"+                               , "InvalidAttributeValueException"+                               , "InvalidAttributesException"+                               , "InvalidClassException"+                               , "InvalidDnDOperationException"+                               , "InvalidKeyException"+                               , "InvalidKeySpecException"+                               , "InvalidMarkException"+                               , "InvalidMidiDataException"+                               , "InvalidName"+                               , "InvalidNameException"+                               , "InvalidNameHelper"+                               , "InvalidNameHolder"+                               , "InvalidObjectException"+                               , "InvalidOpenTypeException"+                               , "InvalidParameterException"+                               , "InvalidParameterSpecException"+                               , "InvalidPolicy"+                               , "InvalidPolicyHelper"+                               , "InvalidPreferencesFormatException"+                               , "InvalidPropertiesFormatException"+                               , "InvalidRelationIdException"+                               , "InvalidRelationServiceException"+                               , "InvalidRelationTypeException"+                               , "InvalidRoleInfoException"+                               , "InvalidRoleValueException"+                               , "InvalidSearchControlsException"+                               , "InvalidSearchFilterException"+                               , "InvalidSeq"+                               , "InvalidSlot"+                               , "InvalidSlotHelper"+                               , "InvalidTargetObjectTypeException"+                               , "InvalidTransactionException"+                               , "InvalidTypeForEncoding"+                               , "InvalidTypeForEncodingHelper"+                               , "InvalidValue"+                               , "InvalidValueHelper"+                               , "Invocable"+                               , "InvocationEvent"+                               , "InvocationHandler"+                               , "InvocationTargetException"+                               , "InvokeHandler"+                               , "IstringHelper"+                               , "ItemEvent"+                               , "ItemListener"+                               , "ItemSelectable"+                               , "Iterable"+                               , "Iterator"+                               , "IvParameterSpec"+                               , "JAXBContext"+                               , "JAXBElement"+                               , "JAXBException"+                               , "JAXBIntrospector"+                               , "JAXBResult"+                               , "JAXBSource"+                               , "JApplet"+                               , "JButton"+                               , "JCheckBox"+                               , "JCheckBoxMenuItem"+                               , "JColorChooser"+                               , "JComboBox"+                               , "JComboBox.KeySelectionManager"+                               , "JComponent"+                               , "JDesktopPane"+                               , "JDialog"+                               , "JEditorPane"+                               , "JFileChooser"+                               , "JFormattedTextField"+                               , "JFormattedTextField.AbstractFormatter"+                               , "JFormattedTextField.AbstractFormatterFactory"+                               , "JFrame"+                               , "JInternalFrame"+                               , "JInternalFrame.JDesktopIcon"+                               , "JLabel"+                               , "JLayeredPane"+                               , "JList"+                               , "JMException"+                               , "JMRuntimeException"+                               , "JMX"+                               , "JMXAddressable"+                               , "JMXAuthenticator"+                               , "JMXConnectionNotification"+                               , "JMXConnector"+                               , "JMXConnectorFactory"+                               , "JMXConnectorProvider"+                               , "JMXConnectorServer"+                               , "JMXConnectorServerFactory"+                               , "JMXConnectorServerMBean"+                               , "JMXConnectorServerProvider"+                               , "JMXPrincipal"+                               , "JMXProviderException"+                               , "JMXServerErrorException"+                               , "JMXServiceURL"+                               , "JMenu"+                               , "JMenuBar"+                               , "JMenuItem"+                               , "JOptionPane"+                               , "JPEGHuffmanTable"+                               , "JPEGImageReadParam"+                               , "JPEGImageWriteParam"+                               , "JPEGQTable"+                               , "JPanel"+                               , "JPasswordField"+                               , "JPopupMenu"+                               , "JPopupMenu.Separator"+                               , "JProgressBar"+                               , "JRadioButton"+                               , "JRadioButtonMenuItem"+                               , "JRootPane"+                               , "JScrollBar"+                               , "JScrollPane"+                               , "JSeparator"+                               , "JSlider"+                               , "JSpinner"+                               , "JSpinner.DateEditor"+                               , "JSpinner.DefaultEditor"+                               , "JSpinner.ListEditor"+                               , "JSpinner.NumberEditor"+                               , "JSplitPane"+                               , "JTabbedPane"+                               , "JTable"+                               , "JTable.PrintMode"+                               , "JTableHeader"+                               , "JTextArea"+                               , "JTextComponent"+                               , "JTextComponent.KeyBinding"+                               , "JTextField"+                               , "JTextPane"+                               , "JToggleButton"+                               , "JToggleButton.ToggleButtonModel"+                               , "JToolBar"+                               , "JToolBar.Separator"+                               , "JToolTip"+                               , "JTree"+                               , "JTree.DynamicUtilTreeNode"+                               , "JTree.EmptySelectionModel"+                               , "JViewport"+                               , "JWindow"+                               , "JarEntry"+                               , "JarException"+                               , "JarFile"+                               , "JarInputStream"+                               , "JarOutputStream"+                               , "JarURLConnection"+                               , "JavaCompiler"+                               , "JavaFileManager"+                               , "JavaFileObject"+                               , "JdbcRowSet"+                               , "JobAttributes"+                               , "JobAttributes.DefaultSelectionType"+                               , "JobAttributes.DestinationType"+                               , "JobAttributes.DialogType"+                               , "JobAttributes.MultipleDocumentHandlingType"+                               , "JobAttributes.SidesType"+                               , "JobHoldUntil"+                               , "JobImpressions"+                               , "JobImpressionsCompleted"+                               , "JobImpressionsSupported"+                               , "JobKOctets"+                               , "JobKOctetsProcessed"+                               , "JobKOctetsSupported"+                               , "JobMediaSheets"+                               , "JobMediaSheetsCompleted"+                               , "JobMediaSheetsSupported"+                               , "JobMessageFromOperator"+                               , "JobName"+                               , "JobOriginatingUserName"+                               , "JobPriority"+                               , "JobPrioritySupported"+                               , "JobSheets"+                               , "JobState"+                               , "JobStateReason"+                               , "JobStateReasons"+                               , "JoinRowSet"+                               , "Joinable"+                               , "KerberosKey"+                               , "KerberosPrincipal"+                               , "KerberosTicket"+                               , "Kernel"+                               , "Key"+                               , "KeyAdapter"+                               , "KeyAgreement"+                               , "KeyAgreementSpi"+                               , "KeyAlreadyExistsException"+                               , "KeyEvent"+                               , "KeyEventDispatcher"+                               , "KeyEventPostProcessor"+                               , "KeyException"+                               , "KeyFactory"+                               , "KeyFactorySpi"+                               , "KeyGenerator"+                               , "KeyGeneratorSpi"+                               , "KeyInfo"+                               , "KeyInfoFactory"+                               , "KeyListener"+                               , "KeyManagementException"+                               , "KeyManager"+                               , "KeyManagerFactory"+                               , "KeyManagerFactorySpi"+                               , "KeyName"+                               , "KeyPair"+                               , "KeyPairGenerator"+                               , "KeyPairGeneratorSpi"+                               , "KeyRep"+                               , "KeyRep.Type"+                               , "KeySelector"+                               , "KeySelectorException"+                               , "KeySelectorResult"+                               , "KeySpec"+                               , "KeyStore"+                               , "KeyStore.Builder"+                               , "KeyStore.CallbackHandlerProtection"+                               , "KeyStore.Entry"+                               , "KeyStore.LoadStoreParameter"+                               , "KeyStore.PasswordProtection"+                               , "KeyStore.PrivateKeyEntry"+                               , "KeyStore.ProtectionParameter"+                               , "KeyStore.SecretKeyEntry"+                               , "KeyStore.TrustedCertificateEntry"+                               , "KeyStoreBuilderParameters"+                               , "KeyStoreException"+                               , "KeyStoreSpi"+                               , "KeyStroke"+                               , "KeyValue"+                               , "KeyboardFocusManager"+                               , "Keymap"+                               , "LDAPCertStoreParameters"+                               , "LIFESPAN_POLICY_ID"+                               , "LOCATION_FORWARD"+                               , "LSException"+                               , "LSInput"+                               , "LSLoadEvent"+                               , "LSOutput"+                               , "LSParser"+                               , "LSParserFilter"+                               , "LSProgressEvent"+                               , "LSResourceResolver"+                               , "LSSerializer"+                               , "LSSerializerFilter"+                               , "Label"+                               , "LabelUI"+                               , "LabelView"+                               , "LanguageCallback"+                               , "LastOwnerException"+                               , "LayeredHighlighter"+                               , "LayeredHighlighter.LayerPainter"+                               , "LayoutFocusTraversalPolicy"+                               , "LayoutManager"+                               , "LayoutManager2"+                               , "LayoutPath"+                               , "LayoutQueue"+                               , "LayoutStyle"+                               , "LdapContext"+                               , "LdapName"+                               , "LdapReferralException"+                               , "Lease"+                               , "Level"+                               , "LexicalHandler"+                               , "LifespanPolicy"+                               , "LifespanPolicyOperations"+                               , "LifespanPolicyValue"+                               , "LimitExceededException"+                               , "Line"+                               , "Line.Info"+                               , "Line2D"+                               , "Line2D.Double"+                               , "Line2D.Float"+                               , "LineBorder"+                               , "LineBreakMeasurer"+                               , "LineEvent"+                               , "LineEvent.Type"+                               , "LineListener"+                               , "LineMetrics"+                               , "LineNumberInputStream"+                               , "LineNumberReader"+                               , "LineUnavailableException"+                               , "LinearGradientPaint"+                               , "LinkException"+                               , "LinkLoopException"+                               , "LinkRef"+                               , "LinkageError"+                               , "LinkedBlockingDeque"+                               , "LinkedBlockingQueue"+                               , "LinkedHashMap"+                               , "LinkedHashSet"+                               , "LinkedList"+                               , "List"+                               , "ListCellRenderer"+                               , "ListDataEvent"+                               , "ListDataListener"+                               , "ListIterator"+                               , "ListModel"+                               , "ListResourceBundle"+                               , "ListSelectionEvent"+                               , "ListSelectionListener"+                               , "ListSelectionModel"+                               , "ListUI"+                               , "ListView"+                               , "ListenerNotFoundException"+                               , "LoaderHandler"+                               , "LocalObject"+                               , "Locale"+                               , "LocaleNameProvider"+                               , "LocaleServiceProvider"+                               , "LocateRegistry"+                               , "Location"+                               , "Locator"+                               , "Locator2"+                               , "Locator2Impl"+                               , "LocatorImpl"+                               , "Lock"+                               , "LockInfo"+                               , "LockSupport"+                               , "LogManager"+                               , "LogRecord"+                               , "LogStream"+                               , "Logger"+                               , "LoggingMXBean"+                               , "LoggingPermission"+                               , "LogicalHandler"+                               , "LogicalMessage"+                               , "LogicalMessageContext"+                               , "LoginContext"+                               , "LoginException"+                               , "LoginModule"+                               , "Long"+                               , "LongBuffer"+                               , "LongHolder"+                               , "LongLongSeqHelper"+                               , "LongLongSeqHolder"+                               , "LongSeqHelper"+                               , "LongSeqHolder"+                               , "LookAndFeel"+                               , "LookupOp"+                               , "LookupTable"+                               , "MARSHAL"+                               , "MBeanAttributeInfo"+                               , "MBeanConstructorInfo"+                               , "MBeanException"+                               , "MBeanFeatureInfo"+                               , "MBeanInfo"+                               , "MBeanNotificationInfo"+                               , "MBeanOperationInfo"+                               , "MBeanParameterInfo"+                               , "MBeanPermission"+                               , "MBeanRegistration"+                               , "MBeanRegistrationException"+                               , "MBeanServer"+                               , "MBeanServerBuilder"+                               , "MBeanServerConnection"+                               , "MBeanServerDelegate"+                               , "MBeanServerDelegateMBean"+                               , "MBeanServerFactory"+                               , "MBeanServerForwarder"+                               , "MBeanServerInvocationHandler"+                               , "MBeanServerNotification"+                               , "MBeanServerNotificationFilter"+                               , "MBeanServerPermission"+                               , "MBeanTrustPermission"+                               , "MGF1ParameterSpec"+                               , "MLet"+                               , "MLetContent"+                               , "MLetMBean"+                               , "MXBean"+                               , "Mac"+                               , "MacSpi"+                               , "MailcapCommandMap"+                               , "MalformedInputException"+                               , "MalformedLinkException"+                               , "MalformedObjectNameException"+                               , "MalformedParameterizedTypeException"+                               , "MalformedURLException"+                               , "ManageReferralControl"+                               , "ManagementFactory"+                               , "ManagementPermission"+                               , "ManagerFactoryParameters"+                               , "Manifest"+                               , "Map"+                               , "Map.Entry"+                               , "MappedByteBuffer"+                               , "MarshalException"+                               , "MarshalledObject"+                               , "Marshaller"+                               , "MaskFormatter"+                               , "MatchResult"+                               , "Matcher"+                               , "Math"+                               , "MathContext"+                               , "MatteBorder"+                               , "Media"+                               , "MediaName"+                               , "MediaPrintableArea"+                               , "MediaSize"+                               , "MediaSize.Engineering"+                               , "MediaSize.ISO"+                               , "MediaSize.JIS"+                               , "MediaSize.NA"+                               , "MediaSize.Other"+                               , "MediaSizeName"+                               , "MediaTracker"+                               , "MediaTray"+                               , "Member"+                               , "MemoryCacheImageInputStream"+                               , "MemoryCacheImageOutputStream"+                               , "MemoryHandler"+                               , "MemoryImageSource"+                               , "MemoryMXBean"+                               , "MemoryManagerMXBean"+                               , "MemoryNotificationInfo"+                               , "MemoryPoolMXBean"+                               , "MemoryType"+                               , "MemoryUsage"+                               , "Menu"+                               , "MenuBar"+                               , "MenuBarUI"+                               , "MenuComponent"+                               , "MenuContainer"+                               , "MenuDragMouseEvent"+                               , "MenuDragMouseListener"+                               , "MenuElement"+                               , "MenuEvent"+                               , "MenuItem"+                               , "MenuItemUI"+                               , "MenuKeyEvent"+                               , "MenuKeyListener"+                               , "MenuListener"+                               , "MenuSelectionManager"+                               , "MenuShortcut"+                               , "MessageContext"+                               , "MessageDigest"+                               , "MessageDigestSpi"+                               , "MessageFactory"+                               , "MessageFormat"+                               , "MessageFormat.Field"+                               , "MessageProp"+                               , "Messager"+                               , "MetaEventListener"+                               , "MetaMessage"+                               , "MetalBorders"+                               , "MetalBorders.ButtonBorder"+                               , "MetalBorders.Flush3DBorder"+                               , "MetalBorders.InternalFrameBorder"+                               , "MetalBorders.MenuBarBorder"+                               , "MetalBorders.MenuItemBorder"+                               , "MetalBorders.OptionDialogBorder"+                               , "MetalBorders.PaletteBorder"+                               , "MetalBorders.PopupMenuBorder"+                               , "MetalBorders.RolloverButtonBorder"+                               , "MetalBorders.ScrollPaneBorder"+                               , "MetalBorders.TableHeaderBorder"+                               , "MetalBorders.TextFieldBorder"+                               , "MetalBorders.ToggleButtonBorder"+                               , "MetalBorders.ToolBarBorder"+                               , "MetalButtonUI"+                               , "MetalCheckBoxIcon"+                               , "MetalCheckBoxUI"+                               , "MetalComboBoxButton"+                               , "MetalComboBoxEditor"+                               , "MetalComboBoxEditor.UIResource"+                               , "MetalComboBoxIcon"+                               , "MetalComboBoxUI"+                               , "MetalDesktopIconUI"+                               , "MetalFileChooserUI"+                               , "MetalIconFactory"+                               , "MetalIconFactory.FileIcon16"+                               , "MetalIconFactory.FolderIcon16"+                               , "MetalIconFactory.PaletteCloseIcon"+                               , "MetalIconFactory.TreeControlIcon"+                               , "MetalIconFactory.TreeFolderIcon"+                               , "MetalIconFactory.TreeLeafIcon"+                               , "MetalInternalFrameTitlePane"+                               , "MetalInternalFrameUI"+                               , "MetalLabelUI"+                               , "MetalLookAndFeel"+                               , "MetalMenuBarUI"+                               , "MetalPopupMenuSeparatorUI"+                               , "MetalProgressBarUI"+                               , "MetalRadioButtonUI"+                               , "MetalRootPaneUI"+                               , "MetalScrollBarUI"+                               , "MetalScrollButton"+                               , "MetalScrollPaneUI"+                               , "MetalSeparatorUI"+                               , "MetalSliderUI"+                               , "MetalSplitPaneUI"+                               , "MetalTabbedPaneUI"+                               , "MetalTextFieldUI"+                               , "MetalTheme"+                               , "MetalToggleButtonUI"+                               , "MetalToolBarUI"+                               , "MetalToolTipUI"+                               , "MetalTreeUI"+                               , "Method"+                               , "MethodDescriptor"+                               , "MidiChannel"+                               , "MidiDevice"+                               , "MidiDevice.Info"+                               , "MidiDeviceProvider"+                               , "MidiEvent"+                               , "MidiFileFormat"+                               , "MidiFileReader"+                               , "MidiFileWriter"+                               , "MidiMessage"+                               , "MidiSystem"+                               , "MidiUnavailableException"+                               , "MimeHeader"+                               , "MimeHeaders"+                               , "MimeType"+                               , "MimeTypeParameterList"+                               , "MimeTypeParseException"+                               , "MimetypesFileTypeMap"+                               , "MinimalHTMLWriter"+                               , "MirroredTypeException"+                               , "MirroredTypesException"+                               , "MissingFormatArgumentException"+                               , "MissingFormatWidthException"+                               , "MissingResourceException"+                               , "Mixer"+                               , "Mixer.Info"+                               , "MixerProvider"+                               , "ModelMBean"+                               , "ModelMBeanAttributeInfo"+                               , "ModelMBeanConstructorInfo"+                               , "ModelMBeanInfo"+                               , "ModelMBeanInfoSupport"+                               , "ModelMBeanNotificationBroadcaster"+                               , "ModelMBeanNotificationInfo"+                               , "ModelMBeanOperationInfo"+                               , "ModificationItem"+                               , "Modifier"+                               , "Monitor"+                               , "MonitorInfo"+                               , "MonitorMBean"+                               , "MonitorNotification"+                               , "MonitorSettingException"+                               , "MouseAdapter"+                               , "MouseDragGestureRecognizer"+                               , "MouseEvent"+                               , "MouseInfo"+                               , "MouseInputAdapter"+                               , "MouseInputListener"+                               , "MouseListener"+                               , "MouseMotionAdapter"+                               , "MouseMotionListener"+                               , "MouseWheelEvent"+                               , "MouseWheelListener"+                               , "MultiButtonUI"+                               , "MultiColorChooserUI"+                               , "MultiComboBoxUI"+                               , "MultiDesktopIconUI"+                               , "MultiDesktopPaneUI"+                               , "MultiDoc"+                               , "MultiDocPrintJob"+                               , "MultiDocPrintService"+                               , "MultiFileChooserUI"+                               , "MultiInternalFrameUI"+                               , "MultiLabelUI"+                               , "MultiListUI"+                               , "MultiLookAndFeel"+                               , "MultiMenuBarUI"+                               , "MultiMenuItemUI"+                               , "MultiOptionPaneUI"+                               , "MultiPanelUI"+                               , "MultiPixelPackedSampleModel"+                               , "MultiPopupMenuUI"+                               , "MultiProgressBarUI"+                               , "MultiRootPaneUI"+                               , "MultiScrollBarUI"+                               , "MultiScrollPaneUI"+                               , "MultiSeparatorUI"+                               , "MultiSliderUI"+                               , "MultiSpinnerUI"+                               , "MultiSplitPaneUI"+                               , "MultiTabbedPaneUI"+                               , "MultiTableHeaderUI"+                               , "MultiTableUI"+                               , "MultiTextUI"+                               , "MultiToolBarUI"+                               , "MultiToolTipUI"+                               , "MultiTreeUI"+                               , "MultiViewportUI"+                               , "MulticastSocket"+                               , "MultipleComponentProfileHelper"+                               , "MultipleComponentProfileHolder"+                               , "MultipleDocumentHandling"+                               , "MultipleGradientPaint"+                               , "MultipleMaster"+                               , "MutableAttributeSet"+                               , "MutableComboBoxModel"+                               , "MutableTreeNode"+                               , "MutationEvent"+                               , "NClob"+                               , "NON_EXISTENT"+                               , "NO_IMPLEMENT"+                               , "NO_MEMORY"+                               , "NO_PERMISSION"+                               , "NO_RESOURCES"+                               , "NO_RESPONSE"+                               , "NVList"+                               , "Name"+                               , "NameAlreadyBoundException"+                               , "NameCallback"+                               , "NameClassPair"+                               , "NameComponent"+                               , "NameComponentHelper"+                               , "NameComponentHolder"+                               , "NameDynAnyPair"+                               , "NameDynAnyPairHelper"+                               , "NameDynAnyPairSeqHelper"+                               , "NameHelper"+                               , "NameHolder"+                               , "NameList"+                               , "NameNotFoundException"+                               , "NameParser"+                               , "NameValuePair"+                               , "NameValuePairHelper"+                               , "NameValuePairSeqHelper"+                               , "NamedNodeMap"+                               , "NamedValue"+                               , "Namespace"+                               , "NamespaceChangeListener"+                               , "NamespaceContext"+                               , "NamespaceSupport"+                               , "Naming"+                               , "NamingContext"+                               , "NamingContextExt"+                               , "NamingContextExtHelper"+                               , "NamingContextExtHolder"+                               , "NamingContextExtOperations"+                               , "NamingContextExtPOA"+                               , "NamingContextHelper"+                               , "NamingContextHolder"+                               , "NamingContextOperations"+                               , "NamingContextPOA"+                               , "NamingEnumeration"+                               , "NamingEvent"+                               , "NamingException"+                               , "NamingExceptionEvent"+                               , "NamingListener"+                               , "NamingManager"+                               , "NamingSecurityException"+                               , "NavigableMap"+                               , "NavigableSet"+                               , "NavigationFilter"+                               , "NavigationFilter.FilterBypass"+                               , "NegativeArraySizeException"+                               , "NestingKind"+                               , "NetPermission"+                               , "NetworkInterface"+                               , "NoClassDefFoundError"+                               , "NoConnectionPendingException"+                               , "NoContext"+                               , "NoContextHelper"+                               , "NoInitialContextException"+                               , "NoPermissionException"+                               , "NoRouteToHostException"+                               , "NoServant"+                               , "NoServantHelper"+                               , "NoSuchAlgorithmException"+                               , "NoSuchAttributeException"+                               , "NoSuchElementException"+                               , "NoSuchFieldError"+                               , "NoSuchFieldException"+                               , "NoSuchMechanismException"+                               , "NoSuchMethodError"+                               , "NoSuchMethodException"+                               , "NoSuchObjectException"+                               , "NoSuchPaddingException"+                               , "NoSuchProviderException"+                               , "NoType"+                               , "Node"+                               , "NodeChangeEvent"+                               , "NodeChangeListener"+                               , "NodeList"+                               , "NodeSetData"+                               , "NonReadableChannelException"+                               , "NonWritableChannelException"+                               , "NoninvertibleTransformException"+                               , "NormalizedStringAdapter"+                               , "Normalizer"+                               , "NotActiveException"+                               , "NotBoundException"+                               , "NotCompliantMBeanException"+                               , "NotContextException"+                               , "NotEmpty"+                               , "NotEmptyHelper"+                               , "NotEmptyHolder"+                               , "NotFound"+                               , "NotFoundHelper"+                               , "NotFoundHolder"+                               , "NotFoundReason"+                               , "NotFoundReasonHelper"+                               , "NotFoundReasonHolder"+                               , "NotIdentifiableEvent"+                               , "NotIdentifiableEventImpl"+                               , "NotOwnerException"+                               , "NotSerializableException"+                               , "NotYetBoundException"+                               , "NotYetConnectedException"+                               , "Notation"+                               , "NotationDeclaration"+                               , "Notification"+                               , "NotificationBroadcaster"+                               , "NotificationBroadcasterSupport"+                               , "NotificationEmitter"+                               , "NotificationFilter"+                               , "NotificationFilterSupport"+                               , "NotificationListener"+                               , "NotificationResult"+                               , "NullCipher"+                               , "NullPointerException"+                               , "NullType"+                               , "Number"+                               , "NumberFormat"+                               , "NumberFormat.Field"+                               , "NumberFormatException"+                               , "NumberFormatProvider"+                               , "NumberFormatter"+                               , "NumberOfDocuments"+                               , "NumberOfInterveningJobs"+                               , "NumberUp"+                               , "NumberUpSupported"+                               , "NumericShaper"+                               , "OAEPParameterSpec"+                               , "OBJECT_NOT_EXIST"+                               , "OBJ_ADAPTER"+                               , "OMGVMCID"+                               , "ORB"+                               , "ORBIdHelper"+                               , "ORBInitInfo"+                               , "ORBInitInfoOperations"+                               , "ORBInitializer"+                               , "ORBInitializerOperations"+                               , "ObjID"+                               , "Object"+                               , "ObjectAlreadyActive"+                               , "ObjectAlreadyActiveHelper"+                               , "ObjectChangeListener"+                               , "ObjectFactory"+                               , "ObjectFactoryBuilder"+                               , "ObjectHelper"+                               , "ObjectHolder"+                               , "ObjectIdHelper"+                               , "ObjectImpl"+                               , "ObjectInput"+                               , "ObjectInputStream"+                               , "ObjectInputStream.GetField"+                               , "ObjectInputValidation"+                               , "ObjectInstance"+                               , "ObjectName"+                               , "ObjectNotActive"+                               , "ObjectNotActiveHelper"+                               , "ObjectOutput"+                               , "ObjectOutputStream"+                               , "ObjectOutputStream.PutField"+                               , "ObjectReferenceFactory"+                               , "ObjectReferenceFactoryHelper"+                               , "ObjectReferenceFactoryHolder"+                               , "ObjectReferenceTemplate"+                               , "ObjectReferenceTemplateHelper"+                               , "ObjectReferenceTemplateHolder"+                               , "ObjectReferenceTemplateSeqHelper"+                               , "ObjectReferenceTemplateSeqHolder"+                               , "ObjectStreamClass"+                               , "ObjectStreamConstants"+                               , "ObjectStreamException"+                               , "ObjectStreamField"+                               , "ObjectView"+                               , "Observable"+                               , "Observer"+                               , "OceanTheme"+                               , "OctetSeqHelper"+                               , "OctetSeqHolder"+                               , "OctetStreamData"+                               , "Oid"+                               , "Oneway"+                               , "OpenDataException"+                               , "OpenMBeanAttributeInfo"+                               , "OpenMBeanAttributeInfoSupport"+                               , "OpenMBeanConstructorInfo"+                               , "OpenMBeanConstructorInfoSupport"+                               , "OpenMBeanInfo"+                               , "OpenMBeanInfoSupport"+                               , "OpenMBeanOperationInfo"+                               , "OpenMBeanOperationInfoSupport"+                               , "OpenMBeanParameterInfo"+                               , "OpenMBeanParameterInfoSupport"+                               , "OpenType"+                               , "OperatingSystemMXBean"+                               , "Operation"+                               , "OperationNotSupportedException"+                               , "OperationsException"+                               , "Option"+                               , "OptionChecker"+                               , "OptionPaneUI"+                               , "OptionalDataException"+                               , "OrientationRequested"+                               , "OutOfMemoryError"+                               , "OutputDeviceAssigned"+                               , "OutputKeys"+                               , "OutputStream"+                               , "OutputStreamWriter"+                               , "OverlappingFileLockException"+                               , "OverlayLayout"+                               , "Override"+                               , "Owner"+                               , "PBEKey"+                               , "PBEKeySpec"+                               , "PBEParameterSpec"+                               , "PDLOverrideSupported"+                               , "PERSIST_STORE"+                               , "PGPData"+                               , "PKCS8EncodedKeySpec"+                               , "PKIXBuilderParameters"+                               , "PKIXCertPathBuilderResult"+                               , "PKIXCertPathChecker"+                               , "PKIXCertPathValidatorResult"+                               , "PKIXParameters"+                               , "POA"+                               , "POAHelper"+                               , "POAManager"+                               , "POAManagerOperations"+                               , "POAOperations"+                               , "PRIVATE_MEMBER"+                               , "PSSParameterSpec"+                               , "PSource"+                               , "PSource.PSpecified"+                               , "PUBLIC_MEMBER"+                               , "Pack200"+                               , "Pack200.Packer"+                               , "Pack200.Unpacker"+                               , "Package"+                               , "PackageElement"+                               , "PackedColorModel"+                               , "PageAttributes"+                               , "PageAttributes.ColorType"+                               , "PageAttributes.MediaType"+                               , "PageAttributes.OrientationRequestedType"+                               , "PageAttributes.OriginType"+                               , "PageAttributes.PrintQualityType"+                               , "PageFormat"+                               , "PageRanges"+                               , "Pageable"+                               , "PagedResultsControl"+                               , "PagedResultsResponseControl"+                               , "PagesPerMinute"+                               , "PagesPerMinuteColor"+                               , "Paint"+                               , "PaintContext"+                               , "PaintEvent"+                               , "Panel"+                               , "PanelUI"+                               , "Paper"+                               , "ParagraphView"+                               , "Parameter"+                               , "ParameterBlock"+                               , "ParameterDescriptor"+                               , "ParameterMetaData"+                               , "ParameterMode"+                               , "ParameterModeHelper"+                               , "ParameterModeHolder"+                               , "ParameterizedType"+                               , "ParseConversionEvent"+                               , "ParseConversionEventImpl"+                               , "ParseException"+                               , "ParsePosition"+                               , "Parser"+                               , "ParserAdapter"+                               , "ParserConfigurationException"+                               , "ParserDelegator"+                               , "ParserFactory"+                               , "PartialResultException"+                               , "PasswordAuthentication"+                               , "PasswordCallback"+                               , "PasswordView"+                               , "Patch"+                               , "Path2D"+                               , "PathIterator"+                               , "Pattern"+                               , "PatternSyntaxException"+                               , "Permission"+                               , "PermissionCollection"+                               , "Permissions"+                               , "PersistenceDelegate"+                               , "PersistentMBean"+                               , "PhantomReference"+                               , "Pipe"+                               , "Pipe.SinkChannel"+                               , "Pipe.SourceChannel"+                               , "PipedInputStream"+                               , "PipedOutputStream"+                               , "PipedReader"+                               , "PipedWriter"+                               , "PixelGrabber"+                               , "PixelInterleavedSampleModel"+                               , "PlainDocument"+                               , "PlainView"+                               , "Point"+                               , "Point2D"+                               , "Point2D.Double"+                               , "Point2D.Float"+                               , "PointerInfo"+                               , "Policy"+                               , "PolicyError"+                               , "PolicyErrorCodeHelper"+                               , "PolicyErrorHelper"+                               , "PolicyErrorHolder"+                               , "PolicyFactory"+                               , "PolicyFactoryOperations"+                               , "PolicyHelper"+                               , "PolicyHolder"+                               , "PolicyListHelper"+                               , "PolicyListHolder"+                               , "PolicyNode"+                               , "PolicyOperations"+                               , "PolicyQualifierInfo"+                               , "PolicySpi"+                               , "PolicyTypeHelper"+                               , "Polygon"+                               , "PooledConnection"+                               , "Popup"+                               , "PopupFactory"+                               , "PopupMenu"+                               , "PopupMenuEvent"+                               , "PopupMenuListener"+                               , "PopupMenuUI"+                               , "Port"+                               , "Port.Info"+                               , "PortInfo"+                               , "PortUnreachableException"+                               , "PortableRemoteObject"+                               , "PortableRemoteObjectDelegate"+                               , "Position"+                               , "Position.Bias"+                               , "PostConstruct"+                               , "PreDestroy"+                               , "Predicate"+                               , "PreferenceChangeEvent"+                               , "PreferenceChangeListener"+                               , "Preferences"+                               , "PreferencesFactory"+                               , "PreparedStatement"+                               , "PresentationDirection"+                               , "PrimitiveType"+                               , "Principal"+                               , "PrincipalHolder"+                               , "PrintConversionEvent"+                               , "PrintConversionEventImpl"+                               , "PrintEvent"+                               , "PrintException"+                               , "PrintGraphics"+                               , "PrintJob"+                               , "PrintJobAdapter"+                               , "PrintJobAttribute"+                               , "PrintJobAttributeEvent"+                               , "PrintJobAttributeListener"+                               , "PrintJobAttributeSet"+                               , "PrintJobEvent"+                               , "PrintJobListener"+                               , "PrintQuality"+                               , "PrintRequestAttribute"+                               , "PrintRequestAttributeSet"+                               , "PrintService"+                               , "PrintServiceAttribute"+                               , "PrintServiceAttributeEvent"+                               , "PrintServiceAttributeListener"+                               , "PrintServiceAttributeSet"+                               , "PrintServiceLookup"+                               , "PrintStream"+                               , "PrintWriter"+                               , "Printable"+                               , "PrinterAbortException"+                               , "PrinterException"+                               , "PrinterGraphics"+                               , "PrinterIOException"+                               , "PrinterInfo"+                               , "PrinterIsAcceptingJobs"+                               , "PrinterJob"+                               , "PrinterLocation"+                               , "PrinterMakeAndModel"+                               , "PrinterMessageFromOperator"+                               , "PrinterMoreInfo"+                               , "PrinterMoreInfoManufacturer"+                               , "PrinterName"+                               , "PrinterResolution"+                               , "PrinterState"+                               , "PrinterStateReason"+                               , "PrinterStateReasons"+                               , "PrinterURI"+                               , "PriorityBlockingQueue"+                               , "PriorityQueue"+                               , "PrivateClassLoader"+                               , "PrivateCredentialPermission"+                               , "PrivateKey"+                               , "PrivateMLet"+                               , "PrivilegedAction"+                               , "PrivilegedActionException"+                               , "PrivilegedExceptionAction"+                               , "Process"+                               , "ProcessBuilder"+                               , "ProcessingEnvironment"+                               , "ProcessingInstruction"+                               , "Processor"+                               , "ProfileDataException"+                               , "ProfileIdHelper"+                               , "ProgressBarUI"+                               , "ProgressMonitor"+                               , "ProgressMonitorInputStream"+                               , "Properties"+                               , "PropertyChangeEvent"+                               , "PropertyChangeListener"+                               , "PropertyChangeListenerProxy"+                               , "PropertyChangeSupport"+                               , "PropertyDescriptor"+                               , "PropertyEditor"+                               , "PropertyEditorManager"+                               , "PropertyEditorSupport"+                               , "PropertyException"+                               , "PropertyPermission"+                               , "PropertyResourceBundle"+                               , "PropertyVetoException"+                               , "ProtectionDomain"+                               , "ProtocolException"+                               , "Provider"+                               , "Provider.Service"+                               , "ProviderException"+                               , "Proxy"+                               , "Proxy.Type"+                               , "ProxySelector"+                               , "PublicKey"+                               , "PushbackInputStream"+                               , "PushbackReader"+                               , "QName"+                               , "QuadCurve2D"+                               , "QuadCurve2D.Double"+                               , "QuadCurve2D.Float"+                               , "Query"+                               , "QueryEval"+                               , "QueryExp"+                               , "Queue"+                               , "QueuedJobCount"+                               , "RC2ParameterSpec"+                               , "RC5ParameterSpec"+                               , "REBIND"+                               , "REQUEST_PROCESSING_POLICY_ID"+                               , "RGBImageFilter"+                               , "RMIClassLoader"+                               , "RMIClassLoaderSpi"+                               , "RMIClientSocketFactory"+                               , "RMIConnection"+                               , "RMIConnectionImpl"+                               , "RMIConnectionImpl_Stub"+                               , "RMIConnector"+                               , "RMIConnectorServer"+                               , "RMICustomMaxStreamFormat"+                               , "RMIFailureHandler"+                               , "RMIIIOPServerImpl"+                               , "RMIJRMPServerImpl"+                               , "RMISecurityException"+                               , "RMISecurityManager"+                               , "RMIServer"+                               , "RMIServerImpl"+                               , "RMIServerImpl_Stub"+                               , "RMIServerSocketFactory"+                               , "RMISocketFactory"+                               , "RSAKey"+                               , "RSAKeyGenParameterSpec"+                               , "RSAMultiPrimePrivateCrtKey"+                               , "RSAMultiPrimePrivateCrtKeySpec"+                               , "RSAOtherPrimeInfo"+                               , "RSAPrivateCrtKey"+                               , "RSAPrivateCrtKeySpec"+                               , "RSAPrivateKey"+                               , "RSAPrivateKeySpec"+                               , "RSAPublicKey"+                               , "RSAPublicKeySpec"+                               , "RTFEditorKit"+                               , "RadialGradientPaint"+                               , "Random"+                               , "RandomAccess"+                               , "RandomAccessFile"+                               , "Raster"+                               , "RasterFormatException"+                               , "RasterOp"+                               , "Rdn"+                               , "ReadOnlyBufferException"+                               , "ReadWriteLock"+                               , "Readable"+                               , "ReadableByteChannel"+                               , "Reader"+                               , "RealmCallback"+                               , "RealmChoiceCallback"+                               , "Receiver"+                               , "Rectangle"+                               , "Rectangle2D"+                               , "Rectangle2D.Double"+                               , "Rectangle2D.Float"+                               , "RectangularShape"+                               , "ReentrantLock"+                               , "ReentrantReadWriteLock"+                               , "ReentrantReadWriteLock.ReadLock"+                               , "ReentrantReadWriteLock.WriteLock"+                               , "Ref"+                               , "RefAddr"+                               , "Reference"+                               , "ReferenceQueue"+                               , "ReferenceType"+                               , "ReferenceUriSchemesSupported"+                               , "Referenceable"+                               , "ReferralException"+                               , "ReflectPermission"+                               , "ReflectionException"+                               , "RefreshFailedException"+                               , "Refreshable"+                               , "Region"+                               , "RegisterableService"+                               , "Registry"+                               , "RegistryHandler"+                               , "RejectedExecutionException"+                               , "RejectedExecutionHandler"+                               , "Relation"+                               , "RelationException"+                               , "RelationNotFoundException"+                               , "RelationNotification"+                               , "RelationService"+                               , "RelationServiceMBean"+                               , "RelationServiceNotRegisteredException"+                               , "RelationSupport"+                               , "RelationSupportMBean"+                               , "RelationType"+                               , "RelationTypeNotFoundException"+                               , "RelationTypeSupport"+                               , "RemarshalException"+                               , "Remote"+                               , "RemoteCall"+                               , "RemoteException"+                               , "RemoteObject"+                               , "RemoteObjectInvocationHandler"+                               , "RemoteRef"+                               , "RemoteServer"+                               , "RemoteStub"+                               , "RenderContext"+                               , "RenderableImage"+                               , "RenderableImageOp"+                               , "RenderableImageProducer"+                               , "RenderedImage"+                               , "RenderedImageFactory"+                               , "Renderer"+                               , "RenderingHints"+                               , "RenderingHints.Key"+                               , "RepaintManager"+                               , "ReplicateScaleFilter"+                               , "RepositoryIdHelper"+                               , "Request"+                               , "RequestInfo"+                               , "RequestInfoOperations"+                               , "RequestProcessingPolicy"+                               , "RequestProcessingPolicyOperations"+                               , "RequestProcessingPolicyValue"+                               , "RequestWrapper"+                               , "RequestingUserName"+                               , "RequiredModelMBean"+                               , "RescaleOp"+                               , "ResolutionSyntax"+                               , "ResolveResult"+                               , "Resolver"+                               , "Resource"+                               , "ResourceBundle"+                               , "Resources"+                               , "Response"+                               , "ResponseCache"+                               , "ResponseHandler"+                               , "ResponseWrapper"+                               , "Result"+                               , "ResultSet"+                               , "ResultSetMetaData"+                               , "Retention"+                               , "RetentionPolicy"+                               , "RetrievalMethod"+                               , "ReverbType"+                               , "Robot"+                               , "Role"+                               , "RoleInfo"+                               , "RoleInfoNotFoundException"+                               , "RoleList"+                               , "RoleNotFoundException"+                               , "RoleResult"+                               , "RoleStatus"+                               , "RoleUnresolved"+                               , "RoleUnresolvedList"+                               , "RootPaneContainer"+                               , "RootPaneUI"+                               , "RoundEnvironment"+                               , "RoundRectangle2D"+                               , "RoundRectangle2D.Double"+                               , "RoundRectangle2D.Float"+                               , "RoundingMode"+                               , "RowFilter"+                               , "RowId"+                               , "RowIdLifetime"+                               , "RowMapper"+                               , "RowSet"+                               , "RowSetEvent"+                               , "RowSetInternal"+                               , "RowSetListener"+                               , "RowSetMetaData"+                               , "RowSetMetaDataImpl"+                               , "RowSetReader"+                               , "RowSetWarning"+                               , "RowSetWriter"+                               , "RowSorter"+                               , "RowSorterEvent"+                               , "RowSorterListener"+                               , "RuleBasedCollator"+                               , "RunTime"+                               , "RunTimeOperations"+                               , "Runnable"+                               , "RunnableFuture"+                               , "RunnableScheduledFuture"+                               , "Runtime"+                               , "RuntimeErrorException"+                               , "RuntimeException"+                               , "RuntimeMBeanException"+                               , "RuntimeMXBean"+                               , "RuntimeOperationsException"+                               , "RuntimePermission"+                               , "SAAJMetaFactory"+                               , "SAAJResult"+                               , "SAXException"+                               , "SAXNotRecognizedException"+                               , "SAXNotSupportedException"+                               , "SAXParseException"+                               , "SAXParser"+                               , "SAXParserFactory"+                               , "SAXResult"+                               , "SAXSource"+                               , "SAXTransformerFactory"+                               , "SERVANT_RETENTION_POLICY_ID"+                               , "SOAPBinding"+                               , "SOAPBody"+                               , "SOAPBodyElement"+                               , "SOAPConnection"+                               , "SOAPConnectionFactory"+                               , "SOAPConstants"+                               , "SOAPElement"+                               , "SOAPElementFactory"+                               , "SOAPEnvelope"+                               , "SOAPException"+                               , "SOAPFactory"+                               , "SOAPFault"+                               , "SOAPFaultElement"+                               , "SOAPFaultException"+                               , "SOAPHandler"+                               , "SOAPHeader"+                               , "SOAPHeaderElement"+                               , "SOAPMessage"+                               , "SOAPMessageContext"+                               , "SOAPMessageHandler"+                               , "SOAPMessageHandlers"+                               , "SOAPPart"+                               , "SQLClientInfoException"+                               , "SQLData"+                               , "SQLDataException"+                               , "SQLException"+                               , "SQLFeatureNotSupportedException"+                               , "SQLInput"+                               , "SQLInputImpl"+                               , "SQLIntegrityConstraintViolationException"+                               , "SQLInvalidAuthorizationSpecException"+                               , "SQLNonTransientConnectionException"+                               , "SQLNonTransientException"+                               , "SQLOutput"+                               , "SQLOutputImpl"+                               , "SQLPermission"+                               , "SQLRecoverableException"+                               , "SQLSyntaxErrorException"+                               , "SQLTimeoutException"+                               , "SQLTransactionRollbackException"+                               , "SQLTransientConnectionException"+                               , "SQLTransientException"+                               , "SQLWarning"+                               , "SQLXML"+                               , "SSLContext"+                               , "SSLContextSpi"+                               , "SSLEngine"+                               , "SSLEngineResult"+                               , "SSLEngineResult.HandshakeStatus"+                               , "SSLEngineResult.Status"+                               , "SSLException"+                               , "SSLHandshakeException"+                               , "SSLKeyException"+                               , "SSLParameters"+                               , "SSLPeerUnverifiedException"+                               , "SSLPermission"+                               , "SSLProtocolException"+                               , "SSLServerSocket"+                               , "SSLServerSocketFactory"+                               , "SSLSession"+                               , "SSLSessionBindingEvent"+                               , "SSLSessionBindingListener"+                               , "SSLSessionContext"+                               , "SSLSocket"+                               , "SSLSocketFactory"+                               , "SUCCESSFUL"+                               , "SYNC_WITH_TRANSPORT"+                               , "SYSTEM_EXCEPTION"+                               , "SampleModel"+                               , "Sasl"+                               , "SaslClient"+                               , "SaslClientFactory"+                               , "SaslException"+                               , "SaslServer"+                               , "SaslServerFactory"+                               , "Savepoint"+                               , "Scanner"+                               , "ScatteringByteChannel"+                               , "ScheduledExecutorService"+                               , "ScheduledFuture"+                               , "ScheduledThreadPoolExecutor"+                               , "Schema"+                               , "SchemaFactory"+                               , "SchemaFactoryLoader"+                               , "SchemaOutputResolver"+                               , "SchemaViolationException"+                               , "ScriptContext"+                               , "ScriptEngine"+                               , "ScriptEngineFactory"+                               , "ScriptEngineManager"+                               , "ScriptException"+                               , "ScrollBarUI"+                               , "ScrollPane"+                               , "ScrollPaneAdjustable"+                               , "ScrollPaneConstants"+                               , "ScrollPaneLayout"+                               , "ScrollPaneLayout.UIResource"+                               , "ScrollPaneUI"+                               , "Scrollable"+                               , "Scrollbar"+                               , "SealedObject"+                               , "SearchControls"+                               , "SearchResult"+                               , "SecretKey"+                               , "SecretKeyFactory"+                               , "SecretKeyFactorySpi"+                               , "SecretKeySpec"+                               , "SecureCacheResponse"+                               , "SecureClassLoader"+                               , "SecureRandom"+                               , "SecureRandomSpi"+                               , "Security"+                               , "SecurityException"+                               , "SecurityManager"+                               , "SecurityPermission"+                               , "Segment"+                               , "SelectableChannel"+                               , "SelectionKey"+                               , "Selector"+                               , "SelectorProvider"+                               , "Semaphore"+                               , "SeparatorUI"+                               , "Sequence"+                               , "SequenceInputStream"+                               , "Sequencer"+                               , "Sequencer.SyncMode"+                               , "SerialArray"+                               , "SerialBlob"+                               , "SerialClob"+                               , "SerialDatalink"+                               , "SerialException"+                               , "SerialJavaObject"+                               , "SerialRef"+                               , "SerialStruct"+                               , "Serializable"+                               , "SerializablePermission"+                               , "Servant"+                               , "ServantActivator"+                               , "ServantActivatorHelper"+                               , "ServantActivatorOperations"+                               , "ServantActivatorPOA"+                               , "ServantAlreadyActive"+                               , "ServantAlreadyActiveHelper"+                               , "ServantLocator"+                               , "ServantLocatorHelper"+                               , "ServantLocatorOperations"+                               , "ServantLocatorPOA"+                               , "ServantManager"+                               , "ServantManagerOperations"+                               , "ServantNotActive"+                               , "ServantNotActiveHelper"+                               , "ServantObject"+                               , "ServantRetentionPolicy"+                               , "ServantRetentionPolicyOperations"+                               , "ServantRetentionPolicyValue"+                               , "ServerCloneException"+                               , "ServerError"+                               , "ServerException"+                               , "ServerIdHelper"+                               , "ServerNotActiveException"+                               , "ServerRef"+                               , "ServerRequest"+                               , "ServerRequestInfo"+                               , "ServerRequestInfoOperations"+                               , "ServerRequestInterceptor"+                               , "ServerRequestInterceptorOperations"+                               , "ServerRuntimeException"+                               , "ServerSocket"+                               , "ServerSocketChannel"+                               , "ServerSocketFactory"+                               , "Service"+                               , "ServiceConfigurationError"+                               , "ServiceContext"+                               , "ServiceContextHelper"+                               , "ServiceContextHolder"+                               , "ServiceContextListHelper"+                               , "ServiceContextListHolder"+                               , "ServiceDelegate"+                               , "ServiceDetail"+                               , "ServiceDetailHelper"+                               , "ServiceIdHelper"+                               , "ServiceInformation"+                               , "ServiceInformationHelper"+                               , "ServiceInformationHolder"+                               , "ServiceLoader"+                               , "ServiceMode"+                               , "ServiceNotFoundException"+                               , "ServicePermission"+                               , "ServiceRegistry"+                               , "ServiceRegistry.Filter"+                               , "ServiceUI"+                               , "ServiceUIFactory"+                               , "ServiceUnavailableException"+                               , "Set"+                               , "SetOfIntegerSyntax"+                               , "SetOverrideType"+                               , "SetOverrideTypeHelper"+                               , "Severity"+                               , "Shape"+                               , "ShapeGraphicAttribute"+                               , "SheetCollate"+                               , "Short"+                               , "ShortBuffer"+                               , "ShortBufferException"+                               , "ShortHolder"+                               , "ShortLookupTable"+                               , "ShortMessage"+                               , "ShortSeqHelper"+                               , "ShortSeqHolder"+                               , "Sides"+                               , "Signature"+                               , "SignatureException"+                               , "SignatureMethod"+                               , "SignatureMethodParameterSpec"+                               , "SignatureProperties"+                               , "SignatureProperty"+                               , "SignatureSpi"+                               , "SignedInfo"+                               , "SignedObject"+                               , "Signer"+                               , "SimpleAnnotationValueVisitor6"+                               , "SimpleAttributeSet"+                               , "SimpleBeanInfo"+                               , "SimpleBindings"+                               , "SimpleDateFormat"+                               , "SimpleDoc"+                               , "SimpleElementVisitor6"+                               , "SimpleFormatter"+                               , "SimpleJavaFileObject"+                               , "SimpleScriptContext"+                               , "SimpleTimeZone"+                               , "SimpleType"+                               , "SimpleTypeVisitor6"+                               , "SinglePixelPackedSampleModel"+                               , "SingleSelectionModel"+                               , "Size2DSyntax"+                               , "SizeLimitExceededException"+                               , "SizeRequirements"+                               , "SizeSequence"+                               , "Skeleton"+                               , "SkeletonMismatchException"+                               , "SkeletonNotFoundException"+                               , "SliderUI"+                               , "Socket"+                               , "SocketAddress"+                               , "SocketChannel"+                               , "SocketException"+                               , "SocketFactory"+                               , "SocketHandler"+                               , "SocketImpl"+                               , "SocketImplFactory"+                               , "SocketOptions"+                               , "SocketPermission"+                               , "SocketSecurityException"+                               , "SocketTimeoutException"+                               , "SoftBevelBorder"+                               , "SoftReference"+                               , "SortControl"+                               , "SortKey"+                               , "SortOrder"+                               , "SortResponseControl"+                               , "SortedMap"+                               , "SortedSet"+                               , "SortingFocusTraversalPolicy"+                               , "Soundbank"+                               , "SoundbankReader"+                               , "SoundbankResource"+                               , "Source"+                               , "SourceDataLine"+                               , "SourceLocator"+                               , "SourceVersion"+                               , "SpinnerDateModel"+                               , "SpinnerListModel"+                               , "SpinnerModel"+                               , "SpinnerNumberModel"+                               , "SpinnerUI"+                               , "SplashScreen"+                               , "SplitPaneUI"+                               , "Spring"+                               , "SpringLayout"+                               , "SpringLayout.Constraints"+                               , "SslRMIClientSocketFactory"+                               , "SslRMIServerSocketFactory"+                               , "StAXResult"+                               , "StAXSource"+                               , "Stack"+                               , "StackOverflowError"+                               , "StackTraceElement"+                               , "StandardEmitterMBean"+                               , "StandardJavaFileManager"+                               , "StandardLocation"+                               , "StandardMBean"+                               , "StartDocument"+                               , "StartElement"+                               , "StartTlsRequest"+                               , "StartTlsResponse"+                               , "State"+                               , "StateEdit"+                               , "StateEditable"+                               , "StateFactory"+                               , "Statement"+                               , "StatementEvent"+                               , "StatementEventListener"+                               , "StreamCorruptedException"+                               , "StreamFilter"+                               , "StreamHandler"+                               , "StreamPrintService"+                               , "StreamPrintServiceFactory"+                               , "StreamReaderDelegate"+                               , "StreamResult"+                               , "StreamSource"+                               , "StreamTokenizer"+                               , "Streamable"+                               , "StreamableValue"+                               , "StrictMath"+                               , "String"+                               , "StringBuffer"+                               , "StringBufferInputStream"+                               , "StringBuilder"+                               , "StringCharacterIterator"+                               , "StringContent"+                               , "StringHolder"+                               , "StringIndexOutOfBoundsException"+                               , "StringMonitor"+                               , "StringMonitorMBean"+                               , "StringNameHelper"+                               , "StringReader"+                               , "StringRefAddr"+                               , "StringSelection"+                               , "StringSeqHelper"+                               , "StringSeqHolder"+                               , "StringTokenizer"+                               , "StringValueExp"+                               , "StringValueHelper"+                               , "StringWriter"+                               , "Stroke"+                               , "Struct"+                               , "StructMember"+                               , "StructMemberHelper"+                               , "Stub"+                               , "StubDelegate"+                               , "StubNotFoundException"+                               , "Style"+                               , "StyleConstants"+                               , "StyleConstants.CharacterConstants"+                               , "StyleConstants.ColorConstants"+                               , "StyleConstants.FontConstants"+                               , "StyleConstants.ParagraphConstants"+                               , "StyleContext"+                               , "StyleSheet"+                               , "StyleSheet.BoxPainter"+                               , "StyleSheet.ListPainter"+                               , "StyledDocument"+                               , "StyledEditorKit"+                               , "StyledEditorKit.AlignmentAction"+                               , "StyledEditorKit.BoldAction"+                               , "StyledEditorKit.FontFamilyAction"+                               , "StyledEditorKit.FontSizeAction"+                               , "StyledEditorKit.ForegroundAction"+                               , "StyledEditorKit.ItalicAction"+                               , "StyledEditorKit.StyledTextAction"+                               , "StyledEditorKit.UnderlineAction"+                               , "Subject"+                               , "SubjectDelegationPermission"+                               , "SubjectDomainCombiner"+                               , "SupportedAnnotationTypes"+                               , "SupportedOptions"+                               , "SupportedSourceVersion"+                               , "SupportedValuesAttribute"+                               , "SuppressWarnings"+                               , "SwingConstants"+                               , "SwingPropertyChangeSupport"+                               , "SwingUtilities"+                               , "SwingWorker"+                               , "SyncFactory"+                               , "SyncFactoryException"+                               , "SyncFailedException"+                               , "SyncProvider"+                               , "SyncProviderException"+                               , "SyncResolver"+                               , "SyncScopeHelper"+                               , "SynchronousQueue"+                               , "SynthConstants"+                               , "SynthContext"+                               , "SynthGraphicsUtils"+                               , "SynthLookAndFeel"+                               , "SynthPainter"+                               , "SynthStyle"+                               , "SynthStyleFactory"+                               , "Synthesizer"+                               , "SysexMessage"+                               , "System"+                               , "SystemColor"+                               , "SystemException"+                               , "SystemFlavorMap"+                               , "SystemTray"+                               , "TAG_ALTERNATE_IIOP_ADDRESS"+                               , "TAG_CODE_SETS"+                               , "TAG_INTERNET_IOP"+                               , "TAG_JAVA_CODEBASE"+                               , "TAG_MULTIPLE_COMPONENTS"+                               , "TAG_ORB_TYPE"+                               , "TAG_POLICIES"+                               , "TAG_RMI_CUSTOM_MAX_STREAM_FORMAT"+                               , "TCKind"+                               , "THREAD_POLICY_ID"+                               , "TIMEOUT"+                               , "TRANSACTION_MODE"+                               , "TRANSACTION_REQUIRED"+                               , "TRANSACTION_ROLLEDBACK"+                               , "TRANSACTION_UNAVAILABLE"+                               , "TRANSIENT"+                               , "TRANSPORT_RETRY"+                               , "TabExpander"+                               , "TabSet"+                               , "TabStop"+                               , "TabableView"+                               , "TabbedPaneUI"+                               , "TableCellEditor"+                               , "TableCellRenderer"+                               , "TableColumn"+                               , "TableColumnModel"+                               , "TableColumnModelEvent"+                               , "TableColumnModelListener"+                               , "TableHeaderUI"+                               , "TableModel"+                               , "TableModelEvent"+                               , "TableModelListener"+                               , "TableRowSorter"+                               , "TableStringConverter"+                               , "TableUI"+                               , "TableView"+                               , "TabularData"+                               , "TabularDataSupport"+                               , "TabularType"+                               , "TagElement"+                               , "TaggedComponent"+                               , "TaggedComponentHelper"+                               , "TaggedComponentHolder"+                               , "TaggedProfile"+                               , "TaggedProfileHelper"+                               , "TaggedProfileHolder"+                               , "Target"+                               , "TargetDataLine"+                               , "TargetedNotification"+                               , "Templates"+                               , "TemplatesHandler"+                               , "Text"+                               , "TextAction"+                               , "TextArea"+                               , "TextAttribute"+                               , "TextComponent"+                               , "TextEvent"+                               , "TextField"+                               , "TextHitInfo"+                               , "TextInputCallback"+                               , "TextLayout"+                               , "TextLayout.CaretPolicy"+                               , "TextListener"+                               , "TextMeasurer"+                               , "TextOutputCallback"+                               , "TextSyntax"+                               , "TextUI"+                               , "TexturePaint"+                               , "Thread"+                               , "Thread.State"+                               , "Thread.UncaughtExceptionHandler"+                               , "ThreadDeath"+                               , "ThreadFactory"+                               , "ThreadGroup"+                               , "ThreadInfo"+                               , "ThreadLocal"+                               , "ThreadMXBean"+                               , "ThreadPolicy"+                               , "ThreadPolicyOperations"+                               , "ThreadPolicyValue"+                               , "ThreadPoolExecutor"+                               , "ThreadPoolExecutor.AbortPolicy"+                               , "ThreadPoolExecutor.CallerRunsPolicy"+                               , "ThreadPoolExecutor.DiscardOldestPolicy"+                               , "ThreadPoolExecutor.DiscardPolicy"+                               , "Throwable"+                               , "Tie"+                               , "TileObserver"+                               , "Time"+                               , "TimeLimitExceededException"+                               , "TimeUnit"+                               , "TimeZone"+                               , "TimeZoneNameProvider"+                               , "TimeoutException"+                               , "Timer"+                               , "TimerAlarmClockNotification"+                               , "TimerMBean"+                               , "TimerNotification"+                               , "TimerTask"+                               , "Timestamp"+                               , "TitledBorder"+                               , "TooManyListenersException"+                               , "Tool"+                               , "ToolBarUI"+                               , "ToolProvider"+                               , "ToolTipManager"+                               , "ToolTipUI"+                               , "Toolkit"+                               , "Track"+                               , "TransactionRequiredException"+                               , "TransactionRolledbackException"+                               , "TransactionService"+                               , "TransactionalWriter"+                               , "TransferHandler"+                               , "Transferable"+                               , "Transform"+                               , "TransformAttribute"+                               , "TransformException"+                               , "TransformParameterSpec"+                               , "TransformService"+                               , "Transformer"+                               , "TransformerConfigurationException"+                               , "TransformerException"+                               , "TransformerFactory"+                               , "TransformerFactoryConfigurationError"+                               , "TransformerHandler"+                               , "Transmitter"+                               , "Transparency"+                               , "TrayIcon"+                               , "TreeCellEditor"+                               , "TreeCellRenderer"+                               , "TreeExpansionEvent"+                               , "TreeExpansionListener"+                               , "TreeMap"+                               , "TreeModel"+                               , "TreeModelEvent"+                               , "TreeModelListener"+                               , "TreeNode"+                               , "TreePath"+                               , "TreeSelectionEvent"+                               , "TreeSelectionListener"+                               , "TreeSelectionModel"+                               , "TreeSet"+                               , "TreeUI"+                               , "TreeWillExpandListener"+                               , "TrustAnchor"+                               , "TrustManager"+                               , "TrustManagerFactory"+                               , "TrustManagerFactorySpi"+                               , "Type"+                               , "TypeCode"+                               , "TypeCodeHolder"+                               , "TypeConstraintException"+                               , "TypeElement"+                               , "TypeInfo"+                               , "TypeInfoProvider"+                               , "TypeKind"+                               , "TypeKindVisitor6"+                               , "TypeMirror"+                               , "TypeMismatch"+                               , "TypeMismatchHelper"+                               , "TypeNotPresentException"+                               , "TypeParameterElement"+                               , "TypeVariable"+                               , "TypeVisitor"+                               , "Types"+                               , "UID"+                               , "UIDefaults"+                               , "UIDefaults.ActiveValue"+                               , "UIDefaults.LazyInputMap"+                               , "UIDefaults.LazyValue"+                               , "UIDefaults.ProxyLazyValue"+                               , "UIEvent"+                               , "UIManager"+                               , "UIManager.LookAndFeelInfo"+                               , "UIResource"+                               , "ULongLongSeqHelper"+                               , "ULongLongSeqHolder"+                               , "ULongSeqHelper"+                               , "ULongSeqHolder"+                               , "UNKNOWN"+                               , "UNSUPPORTED_POLICY"+                               , "UNSUPPORTED_POLICY_VALUE"+                               , "URI"+                               , "URIDereferencer"+                               , "URIException"+                               , "URIParameter"+                               , "URIReference"+                               , "URIReferenceException"+                               , "URIResolver"+                               , "URISyntax"+                               , "URISyntaxException"+                               , "URL"+                               , "URLClassLoader"+                               , "URLConnection"+                               , "URLDataSource"+                               , "URLDecoder"+                               , "URLEncoder"+                               , "URLStreamHandler"+                               , "URLStreamHandlerFactory"+                               , "URLStringHelper"+                               , "USER_EXCEPTION"+                               , "UShortSeqHelper"+                               , "UShortSeqHolder"+                               , "UTFDataFormatException"+                               , "UUID"+                               , "UndeclaredThrowableException"+                               , "UndoManager"+                               , "UndoableEdit"+                               , "UndoableEditEvent"+                               , "UndoableEditListener"+                               , "UndoableEditSupport"+                               , "UnexpectedException"+                               , "UnicastRemoteObject"+                               , "UnionMember"+                               , "UnionMemberHelper"+                               , "UnknownAnnotationValueException"+                               , "UnknownElementException"+                               , "UnknownEncoding"+                               , "UnknownEncodingHelper"+                               , "UnknownError"+                               , "UnknownException"+                               , "UnknownFormatConversionException"+                               , "UnknownFormatFlagsException"+                               , "UnknownGroupException"+                               , "UnknownHostException"+                               , "UnknownObjectException"+                               , "UnknownServiceException"+                               , "UnknownTypeException"+                               , "UnknownUserException"+                               , "UnknownUserExceptionHelper"+                               , "UnknownUserExceptionHolder"+                               , "UnmappableCharacterException"+                               , "UnmarshalException"+                               , "Unmarshaller"+                               , "UnmarshallerHandler"+                               , "UnmodifiableClassException"+                               , "UnmodifiableSetException"+                               , "UnrecoverableEntryException"+                               , "UnrecoverableKeyException"+                               , "Unreferenced"+                               , "UnresolvedAddressException"+                               , "UnresolvedPermission"+                               , "UnsatisfiedLinkError"+                               , "UnsolicitedNotification"+                               , "UnsolicitedNotificationEvent"+                               , "UnsolicitedNotificationListener"+                               , "UnsupportedAddressTypeException"+                               , "UnsupportedAudioFileException"+                               , "UnsupportedCallbackException"+                               , "UnsupportedCharsetException"+                               , "UnsupportedClassVersionError"+                               , "UnsupportedDataTypeException"+                               , "UnsupportedEncodingException"+                               , "UnsupportedFlavorException"+                               , "UnsupportedLookAndFeelException"+                               , "UnsupportedOperationException"+                               , "UserDataHandler"+                               , "UserException"+                               , "Util"+                               , "UtilDelegate"+                               , "Utilities"+                               , "VMID"+                               , "VM_ABSTRACT"+                               , "VM_CUSTOM"+                               , "VM_NONE"+                               , "VM_TRUNCATABLE"+                               , "ValidationEvent"+                               , "ValidationEventCollector"+                               , "ValidationEventHandler"+                               , "ValidationEventImpl"+                               , "ValidationEventLocator"+                               , "ValidationEventLocatorImpl"+                               , "ValidationException"+                               , "Validator"+                               , "ValidatorHandler"+                               , "ValueBase"+                               , "ValueBaseHelper"+                               , "ValueBaseHolder"+                               , "ValueExp"+                               , "ValueFactory"+                               , "ValueHandler"+                               , "ValueHandlerMultiFormat"+                               , "ValueInputStream"+                               , "ValueMember"+                               , "ValueMemberHelper"+                               , "ValueOutputStream"+                               , "VariableElement"+                               , "VariableHeightLayoutCache"+                               , "Vector"+                               , "VerifyError"+                               , "VersionSpecHelper"+                               , "VetoableChangeListener"+                               , "VetoableChangeListenerProxy"+                               , "VetoableChangeSupport"+                               , "View"+                               , "ViewFactory"+                               , "ViewportLayout"+                               , "ViewportUI"+                               , "VirtualMachineError"+                               , "Visibility"+                               , "VisibilityHelper"+                               , "VoiceStatus"+                               , "Void"+                               , "VolatileImage"+                               , "W3CDomHandler"+                               , "WCharSeqHelper"+                               , "WCharSeqHolder"+                               , "WStringSeqHelper"+                               , "WStringSeqHolder"+                               , "WStringValueHelper"+                               , "WeakHashMap"+                               , "WeakReference"+                               , "WebEndpoint"+                               , "WebFault"+                               , "WebMethod"+                               , "WebParam"+                               , "WebResult"+                               , "WebRowSet"+                               , "WebService"+                               , "WebServiceClient"+                               , "WebServiceContext"+                               , "WebServiceException"+                               , "WebServicePermission"+                               , "WebServiceProvider"+                               , "WebServiceRef"+                               , "WebServiceRefs"+                               , "WildcardType"+                               , "Window"+                               , "WindowAdapter"+                               , "WindowConstants"+                               , "WindowEvent"+                               , "WindowFocusListener"+                               , "WindowListener"+                               , "WindowStateListener"+                               , "WrappedPlainView"+                               , "Wrapper"+                               , "WritableByteChannel"+                               , "WritableRaster"+                               , "WritableRenderedImage"+                               , "WriteAbortedException"+                               , "Writer"+                               , "WrongAdapter"+                               , "WrongAdapterHelper"+                               , "WrongPolicy"+                               , "WrongPolicyHelper"+                               , "WrongTransaction"+                               , "WrongTransactionHelper"+                               , "WrongTransactionHolder"+                               , "X500Principal"+                               , "X500PrivateCredential"+                               , "X509CRL"+                               , "X509CRLEntry"+                               , "X509CRLSelector"+                               , "X509CertSelector"+                               , "X509Certificate"+                               , "X509Data"+                               , "X509EncodedKeySpec"+                               , "X509ExtendedKeyManager"+                               , "X509Extension"+                               , "X509IssuerSerial"+                               , "X509KeyManager"+                               , "X509TrustManager"+                               , "XAConnection"+                               , "XADataSource"+                               , "XAException"+                               , "XAResource"+                               , "XMLConstants"+                               , "XMLCryptoContext"+                               , "XMLDecoder"+                               , "XMLEncoder"+                               , "XMLEvent"+                               , "XMLEventAllocator"+                               , "XMLEventConsumer"+                               , "XMLEventFactory"+                               , "XMLEventReader"+                               , "XMLEventWriter"+                               , "XMLFilter"+                               , "XMLFilterImpl"+                               , "XMLFormatter"+                               , "XMLGregorianCalendar"+                               , "XMLInputFactory"+                               , "XMLObject"+                               , "XMLOutputFactory"+                               , "XMLParseException"+                               , "XMLReader"+                               , "XMLReaderAdapter"+                               , "XMLReaderFactory"+                               , "XMLReporter"+                               , "XMLResolver"+                               , "XMLSignContext"+                               , "XMLSignature"+                               , "XMLSignatureException"+                               , "XMLSignatureFactory"+                               , "XMLStreamConstants"+                               , "XMLStreamException"+                               , "XMLStreamReader"+                               , "XMLStreamWriter"+                               , "XMLStructure"+                               , "XMLValidateContext"+                               , "XPath"+                               , "XPathConstants"+                               , "XPathException"+                               , "XPathExpression"+                               , "XPathExpressionException"+                               , "XPathFactory"+                               , "XPathFactoryConfigurationException"+                               , "XPathFilter2ParameterSpec"+                               , "XPathFilterParameterSpec"+                               , "XPathFunction"+                               , "XPathFunctionException"+                               , "XPathFunctionResolver"+                               , "XPathType"+                               , "XPathVariableResolver"+                               , "XSLTTransformParameterSpec"+                               , "Xid"+                               , "XmlAccessOrder"+                               , "XmlAccessType"+                               , "XmlAccessorOrder"+                               , "XmlAccessorType"+                               , "XmlAdapter"+                               , "XmlAnyAttribute"+                               , "XmlAnyElement"+                               , "XmlAttachmentRef"+                               , "XmlAttribute"+                               , "XmlElement"+                               , "XmlElementDecl"+                               , "XmlElementRef"+                               , "XmlElementRefs"+                               , "XmlElementWrapper"+                               , "XmlElements"+                               , "XmlEnum"+                               , "XmlEnumValue"+                               , "XmlID"+                               , "XmlIDREF"+                               , "XmlInlineBinaryData"+                               , "XmlJavaTypeAdapter"+                               , "XmlJavaTypeAdapters"+                               , "XmlList"+                               , "XmlMimeType"+                               , "XmlMixed"+                               , "XmlNs"+                               , "XmlNsForm"+                               , "XmlReader"+                               , "XmlRegistry"+                               , "XmlRootElement"+                               , "XmlSchema"+                               , "XmlSchemaType"+                               , "XmlSchemaTypes"+                               , "XmlTransient"+                               , "XmlType"+                               , "XmlValue"+                               , "XmlWriter"+                               , "ZipEntry"+                               , "ZipError"+                               , "ZipException"+                               , "ZipFile"+                               , "ZipInputStream"+                               , "ZipOutputStream"+                               , "ZoneView"+                               , "_BindingIteratorImplBase"+                               , "_BindingIteratorStub"+                               , "_DynAnyFactoryStub"+                               , "_DynAnyStub"+                               , "_DynArrayStub"+                               , "_DynEnumStub"+                               , "_DynFixedStub"+                               , "_DynSequenceStub"+                               , "_DynStructStub"+                               , "_DynUnionStub"+                               , "_DynValueStub"+                               , "_IDLTypeStub"+                               , "_NamingContextExtStub"+                               , "_NamingContextImplBase"+                               , "_NamingContextStub"+                               , "_PolicyStub"+                               , "_Remote_Stub"+                               , "_ServantActivatorStub"+                               , "_ServantLocatorStub"+                               ])+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren =+                          [ Rule+                              { rMatcher = AnyChar "fF"+                              , rAttribute = FloatTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = True+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren =+                          [ Rule+                              { rMatcher = StringDetect "L"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'\\\\u[0-9a-fA-F]{4}'"+                              , reCompiled = Just (compileRegex True "'\\\\u[0-9a-fA-F]{4}'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "//\\s*BEGIN.*$"+                              , reCompiled = Just (compileRegex True "//\\s*BEGIN.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "//\\s*END.*$"+                              , reCompiled = Just (compileRegex True "//\\s*END.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Java" , "String" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.(format|printf)\\b"+                              , reCompiled = Just (compileRegex True "\\.(format|printf)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Java" , "EnterPrintf" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Java" , "Commentar 1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Java" , "Commentar 2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.{3,3}\\s+"+                              , reCompiled = Just (compileRegex True "\\.{3,3}\\s+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(import\\s+static)\\b"+                              , reCompiled = Just (compileRegex True "\\b(import\\s+static)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Java" , "StaticImports" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(package|import)\\b"+                              , reCompiled = Just (compileRegex True "\\b(package|import)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Java" , "Imports" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b[_\\w][_\\w\\d]*(?=[\\s]*(/\\*\\s*\\d+\\s*\\*/\\s*)?[(])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\b[_\\w][_\\w\\d]*(?=[\\s]*(/\\*\\s*\\d+\\s*\\*/\\s*)?[(])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@[_\\w][_\\w\\d]*"+                              , reCompiled = Just (compileRegex True "@[_\\w][_\\w\\d]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[.]{1,1}"+                              , reCompiled = Just (compileRegex True "[.]{1,1}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Java" , "Member" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Java" , "InFunctionCall" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar ":!%&+,-/.*<=>?[]|~^;"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Printf"+          , Context+              { cName = "Printf"+              , cSyntax = "Java"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Java" , "PrintfString" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Java" , "InFunctionCall" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "PrintfString"+          , Context+              { cName = "PrintfString"+              , cSyntax = "Java"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "%(\\d+\\$)?(-|#|\\+|\\ |0|,|\\()*\\d*(\\.\\d+)?[a-hosxA-CEGHSX]"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "%(\\d+\\$)?(-|#|\\+|\\ |0|,|\\()*\\d*(\\.\\d+)?[a-hosxA-CEGHSX]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "%(\\d+\\$)?(-|#|\\+|\\ |0|,|\\()*\\d*(t|T)(a|A|b|B|c|C|d|D|e|F|h|H|I|j|k|l|L|m|M|N|p|P|Q|r|R|s|S|T|y|Y|z|Z)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "%(\\d+\\$)?(-|#|\\+|\\ |0|,|\\()*\\d*(t|T)(a|A|b|B|c|C|d|D|e|F|h|H|I|j|k|l|L|m|M|N|p|P|Q|r|R|s|S|T|y|Y|z|Z)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%(%|n)"+                              , reCompiled = Just (compileRegex True "%(%|n)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "StaticImports"+          , Context+              { cName = "StaticImports"+              , cSyntax = "Java"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*.*;"+                              , reCompiled = Just (compileRegex True "\\s*.*;")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ImportTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Java"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\u[0-9a-fA-F]{4}"+                              , reCompiled = Just (compileRegex True "\\\\u[0-9a-fA-F]{4}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Alfredo Luiz Foltran Fialho (alfoltran@ig.com.br)"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions = [ "*.java" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Javadoc.hs view
@@ -0,0 +1,1052 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Javadoc (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex++syntax :: Syntax+syntax = Syntax+  { sName = "Javadoc"+  , sFilename = "javadoc.xml"+  , sShortname = "Javadoc"+  , sContexts =+      fromList+        [ ( "FindJavadoc"+          , Context+              { cName = "FindJavadoc"+              , cSyntax = "Javadoc"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "/**/"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "/**"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "JavadocFSar" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "InlineTagar"+          , Context+              { cName = "InlineTagar"+              , cSyntax = "Javadoc"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "HTML" , "" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "JavadocFSar"+          , Context+              { cName = "JavadocFSar"+              , cSyntax = "Javadoc"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(!|\\?)"+                              , reCompiled = Just (compileRegex True "(!|\\?)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "Javadocar" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\.\\s*$)"+                              , reCompiled = Just (compileRegex True "(\\.\\s*$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "Javadocar" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\.\\s)(?![\\da-z])"+                              , reCompiled = Just (compileRegex True "(\\.\\s)(?![\\da-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "Javadocar" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\**\\s*(?=@(author|deprecated|exception|param|return|see|serial|serialData|serialField|since|throws|version)(\\s|$))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\**\\s*(?=@(author|deprecated|exception|param|return|see|serial|serialData|serialField|since|throws|version)(\\s|$))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "Javadocar" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "{@code "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "LiteralTagar" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "{@code "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "LiteralTagar" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "{@docRoot}"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "{@inheritDoc}"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "{@link "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "InlineTagar" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "{@link "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "InlineTagar" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "{@linkplain "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "InlineTagar" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "{@linkplain "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "InlineTagar" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "{@literal "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "LiteralTagar" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "{@literal "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "LiteralTagar" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "{@value}"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "{@value "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "InlineTagar" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "{@value "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "InlineTagar" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "HTML" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "JavadocParam"+          , Context+              { cName = "JavadocParam"+              , cSyntax = "Javadoc"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S*(?=\\*/)"+                              , reCompiled = Just (compileRegex True "\\S*(?=\\*/)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S*(\\s|$)"+                              , reCompiled = Just (compileRegex True "\\S*(\\s|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Javadocar"+          , Context+              { cName = "Javadocar"+              , cSyntax = "Javadoc"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\*+(?!/)"+                              , reCompiled = Just (compileRegex True "\\*+(?!/)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "@author "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "@deprecated "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "@exception "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "JavadocParam" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "@param "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "JavadocParam" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "@return "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "@see "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "SeeTag" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "@serial "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "@serialData "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "@serialField "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "@since "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "@throws "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "JavadocParam" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "@version "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "@author "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "@deprecated "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "@exception "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "JavadocParam" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "@param "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "JavadocParam" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "@return "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "@see "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "SeeTag" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "@serial "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "@serialData "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "@serialField "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "@since "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "@throws "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "JavadocParam" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "@version "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "{@code "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "LiteralTagar" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "{@code "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "LiteralTagar" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "{@docRoot}"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "{@inheritDoc}"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "{@link "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "InlineTagar" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "{@link "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "InlineTagar" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "{@linkplain "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "InlineTagar" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "{@linkplain "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "InlineTagar" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "{@literal "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "LiteralTagar" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "{@literal "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "LiteralTagar" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "{@value}"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "{@value "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "InlineTagar" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "{@value "+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Javadoc" , "InlineTagar" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "HTML" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "LiteralTagar"+          , Context+              { cName = "LiteralTagar"+              , cSyntax = "Javadoc"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SeeTag"+          , Context+              { cName = "SeeTag"+              , cSyntax = "Javadoc"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "HTML" , "" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Start"+          , Context+              { cName = "Start"+              , cSyntax = "Javadoc"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Javadoc" , "FindJavadoc" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Alfredo Luiz Foltran Fialho (alfoltran@ig.com.br)"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions = []+  , sStartingContext = "Start"+  }
+ src/Skylighting/Syntax/Javascript.hs view
@@ -0,0 +1,1438 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Javascript (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "JavaScript"+  , sFilename = "javascript.xml"+  , sShortname = "Javascript"+  , sContexts =+      fromList+        [ ( "(charclass caret first check)"+          , Context+              { cName = "(charclass caret first check)"+              , cSyntax = "JavaScript"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '^'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "JavaScript" , "Regular Expression Character Class" ) ]+                      }+                  ]+              , cAttribute = SpecialCharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext =+                  [ Push ( "JavaScript" , "Regular Expression Character Class" ) ]+              , cDynamic = False+              }+          )+        , ( "(regex caret first check)"+          , Context+              { cName = "(regex caret first check)"+              , cSyntax = "JavaScript"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '^'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JavaScript" , "Regular Expression" ) ]+                      }+                  ]+              , cAttribute = SpecialCharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext =+                  [ Push ( "JavaScript" , "Regular Expression" ) ]+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "JavaScript"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Modelines" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Conditional Expression"+          , Context+              { cName = "Conditional Expression"+              , cSyntax = "JavaScript"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "JavaScript" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Multi/inline Comment"+          , Context+              { cName = "Multi/inline Comment"+              , cSyntax = "JavaScript"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Modelines" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "NoRegExp"+          , Context+              { cName = "NoRegExp"+              , cSyntax = "JavaScript"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '/'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "JavaScript"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "//BEGIN"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JavaScript" , "region_marker" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "//END"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JavaScript" , "region_marker" ) ]+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JavaScript" , "NoRegExp" ) ]+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JavaScript" , "NoRegExp" ) ]+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JavaScript" , "NoRegExp" ) ]+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JavaScript" , "NoRegExp" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "])"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JavaScript" , "NoRegExp" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "break"+                               , "case"+                               , "catch"+                               , "continue"+                               , "debugger"+                               , "do"+                               , "else"+                               , "finally"+                               , "for"+                               , "if"+                               , "return"+                               , "switch"+                               , "throw"+                               , "try"+                               , "while"+                               , "with"+                               ])+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "const"+                               , "delete"+                               , "function"+                               , "in"+                               , "instanceof"+                               , "new"+                               , "this"+                               , "typeof"+                               , "var"+                               , "void"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "class"+                               , "enum"+                               , "extends"+                               , "implements"+                               , "interface"+                               , "let"+                               , "private"+                               , "protected"+                               , "public"+                               , "static"+                               , "super"+                               , "yield"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Infinity" , "NaN" , "false" , "null" , "true" , "undefined" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JavaScript" , "NoRegExp" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "as" , "default" , "export" , "from" , "import" , "package" ])+                      , rAttribute = ImportTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JavaScript" , "Template" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "String.raw`"+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JavaScript" , "RawTemplate" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z_$][\\w$]*(?=\\s*\\.)"+                              , reCompiled =+                                  Just (compileRegex True "[a-zA-Z_$][\\w$]*(?=\\s*\\.)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JavaScript" , "Object Member" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z_$][\\w$]*(?=\\s*\\()"+                              , reCompiled =+                                  Just (compileRegex True "[a-zA-Z_$][\\w$]*(?=\\s*\\()")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JavaScript" , "NoRegExp" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '.'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JavaScript" , "Object Member" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z_$][\\w$]*"+                              , reCompiled = Just (compileRegex True "[a-zA-Z_$][\\w$]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JavaScript" , "NoRegExp" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JavaScript" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JavaScript" , "String SQ" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JavaScript" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "JavaScript" , "Multi/inline Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '/'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "JavaScript" , "(regex caret first check)" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JavaScript" , "Object" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '?'+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "JavaScript" , "Conditional Expression" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar ":!%&+,-/.*<=>?|~^;"+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Object"+          , Context+              { cName = "Object"+              , cSyntax = "JavaScript"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "const"+                               , "delete"+                               , "function"+                               , "in"+                               , "instanceof"+                               , "new"+                               , "this"+                               , "typeof"+                               , "var"+                               , "void"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z_$][\\w$]*\\s*(?=:)"+                              , reCompiled =+                                  Just (compileRegex True "[a-zA-Z_$][\\w$]*\\s*(?=:)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "JavaScript" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Object Member"+          , Context+              { cName = "Object Member"+              , cSyntax = "JavaScript"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '.'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z_$][\\w$]*(?=\\s*\\.)"+                              , reCompiled =+                                  Just (compileRegex True "[a-zA-Z_$][\\w$]*(?=\\s*\\.)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JavaScript" , "Object Member" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z_$][\\w$]*"+                              , reCompiled = Just (compileRegex True "[a-zA-Z_$][\\w$]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "JavaScript" , "NoRegExp" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "RawTemplate"+          , Context+              { cName = "RawTemplate"+              , cSyntax = "JavaScript"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = VerbatimStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Regular Expression"+          , Context+              { cName = "Regular Expression"+              , cSyntax = "JavaScript"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/\\w*"+                              , reCompiled = Just (compileRegex True "/\\w*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{[\\d, ]+\\}"+                              , reCompiled = Just (compileRegex True "\\{[\\d, ]+\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[bB]"+                              , reCompiled = Just (compileRegex True "\\\\[bB]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[nrtvfDdSsWw]"+                              , reCompiled = Just (compileRegex True "\\\\[nrtvfDdSsWw]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "JavaScript" , "(charclass caret first check)" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$(?=/)"+                              , reCompiled = Just (compileRegex True "\\$(?=/)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "?+*()|"+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Regular Expression Character Class"+          , Context+              { cName = "Regular Expression Character Class"+              , cSyntax = "JavaScript"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[\\[\\]]"+                              , reCompiled = Just (compileRegex True "\\\\[\\[\\]]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = SpecialCharTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Shebang"+          , Context+              { cName = "Shebang"+              , cSyntax = "JavaScript"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '#' '!'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "JavaScript" , "Comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "JavaScript" , "Normal" ) ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Push ( "JavaScript" , "Normal" ) ]+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "JavaScript"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\u[0-9a-fA-F]{4}"+                              , reCompiled = Just (compileRegex True "\\\\u[0-9a-fA-F]{4}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String SQ"+          , Context+              { cName = "String SQ"+              , cSyntax = "JavaScript"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\u[0-9a-fA-F]{4}"+                              , reCompiled = Just (compileRegex True "\\\\u[0-9a-fA-F]{4}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Substitution"+          , Context+              { cName = "Substitution"+              , cSyntax = "JavaScript"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "JavaScript" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Template"+          , Context+              { cName = "Template"+              , cSyntax = "JavaScript"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '`'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '{'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JavaScript" , "Substitution" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = VerbatimStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "region_marker"+          , Context+              { cName = "region_marker"+              , cSyntax = "JavaScript"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = RegionMarkerTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor =+      "Anders Lund (anders@alweb.dk), Joseph Wenninger (jowenn@kde.org), Whitehawk Stormchaser (zerokode@gmx.net)"+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.js" , "*.kwinscript" ]+  , sStartingContext = "Shebang"+  }
+ src/Skylighting/Syntax/Json.hs view
@@ -0,0 +1,536 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Json (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "JSON"+  , sFilename = "json.xml"+  , sShortname = "Json"+  , sContexts =+      fromList+        [ ( "Array"+          , Context+              { cName = "Array"+              , cSyntax = "JSON"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSON" , "Pair" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSON" , "Array" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSON" , "String_Value" ) ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "false" , "null" , "true" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-?(?:[0-9]|[1-9][0-9]+)\\.[0-9]+(?:[eE][+-]?[0-9]+)?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "-?(?:[0-9]|[1-9][0-9]+)\\.[0-9]+(?:[eE][+-]?[0-9]+)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-?(?:[0-9]|[1-9][0-9]+)(?:[eE][+-]?[0-9]+)?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "-?(?:[0-9]|[1-9][0-9]+)(?:[eE][+-]?[0-9]+)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "JSON"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSON" , "Pair" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSON" , "Array" ) ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Pair"+          , Context+              { cName = "Pair"+              , cSyntax = "JSON"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSON" , "String_Key" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSON" , "Value" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String_Key"+          , Context+              { cName = "String_Key"+              , cSyntax = "JSON"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(?:[\"\\\\/bfnrt]|u[0-9a-fA-f]{4})"+                              , reCompiled =+                                  Just (compileRegex True "\\\\(?:[\"\\\\/bfnrt]|u[0-9a-fA-f]{4})")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String_Value"+          , Context+              { cName = "String_Value"+              , cSyntax = "JSON"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(?:[\"\\\\/bfnrt]|u[0-9a-fA-f]{4})"+                              , reCompiled =+                                  Just (compileRegex True "\\\\(?:[\"\\\\/bfnrt]|u[0-9a-fA-f]{4})")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Value"+          , Context+              { cName = "Value"+              , cSyntax = "JSON"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSON" , "String_Value" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSON" , "Pair" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSON" , "Array" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "false" , "null" , "true" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-?(?:[0-9]|[1-9][0-9]+)\\.[0-9]+(?:[eE][+-]?[0-9]+)?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "-?(?:[0-9]|[1-9][0-9]+)\\.[0-9]+(?:[eE][+-]?[0-9]+)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-?(?:[0-9]|[1-9][0-9]+)(?:[eE][+-]?[0-9]+)?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "-?(?:[0-9]|[1-9][0-9]+)(?:[eE][+-]?[0-9]+)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Sebastian Pipping (sebastian@pipping.org)"+  , sVersion = "2"+  , sLicense = "GPL"+  , sExtensions = [ "*.json" , ".kateproject" , ".arcconfig" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Jsp.hs view
@@ -0,0 +1,7846 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Jsp (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "JSP"+  , sFilename = "jsp.xml"+  , sShortname = "Jsp"+  , sContexts =+      fromList+        [ ( "Html Attribute"+          , Context+              { cName = "Html Attribute"+              , cSyntax = "JSP"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\/?>"+                              , reCompiled = Just (compileRegex False "\\/?>")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*=\\s*"+                              , reCompiled = Just (compileRegex False "\\s*=\\s*")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Html Value" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<%--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%(!|=)?"+                              , reCompiled = Just (compileRegex False "<%(!|=)?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Scriptlet" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Expression" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Html Comment"+          , Context+              { cName = "Html Comment"+              , cSyntax = "JSP"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<%--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%(!|=)?"+                              , reCompiled = Just (compileRegex False "<%(!|=)?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Scriptlet" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Expression" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\/*-->"+                              , reCompiled = Just (compileRegex False "\\/*-->")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Html Double Quoted Value"+          , Context+              { cName = "Html Double Quoted Value"+              , cSyntax = "JSP"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<%--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%(!|=)?"+                              , reCompiled = Just (compileRegex False "<%(!|=)?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Scriptlet" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Expression" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\s*\\/?\\s*\\$?\\w*:\\$?\\w*"+                              , reCompiled =+                                  Just (compileRegex False "<\\s*\\/?\\s*\\$?\\w*:\\$?\\w*")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Custom Tag" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\"|&quot;|&#34;)"+                              , reCompiled = Just (compileRegex False "(\"|&quot;|&#34;)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Html Single Quoted Value"+          , Context+              { cName = "Html Single Quoted Value"+              , cSyntax = "JSP"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<%--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%(!|=)?"+                              , reCompiled = Just (compileRegex False "<%(!|=)?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Scriptlet" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Expression" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\s*\\/?\\s*\\$?\\w*:\\$?\\w*"+                              , reCompiled =+                                  Just (compileRegex False "<\\s*\\/?\\s*\\$?\\w*:\\$?\\w*")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Custom Tag" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "('|&#39;)"+                              , reCompiled = Just (compileRegex False "('|&#39;)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Html Unquoted Value"+          , Context+              { cName = "Html Unquoted Value"+              , cSyntax = "JSP"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<%--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%(!|=)?"+                              , reCompiled = Just (compileRegex False "<%(!|=)?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Scriptlet" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Expression" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\s*\\/?\\s*\\$?\\w*:\\$?\\w*"+                              , reCompiled =+                                  Just (compileRegex False "<\\s*\\/?\\s*\\$?\\w*:\\$?\\w*")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Custom Tag" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\/?>"+                              , reCompiled = Just (compileRegex False "\\/?>")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+"+                              , reCompiled = Just (compileRegex False "\\s+")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Html Value"+          , Context+              { cName = "Html Value"+              , cSyntax = "JSP"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<%--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%(!|=)?"+                              , reCompiled = Just (compileRegex False "<%(!|=)?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Scriptlet" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Expression" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\s*\\/?\\s*\\$?\\w*:\\$?\\w*"+                              , reCompiled =+                                  Just (compileRegex False "<\\s*\\/?\\s*\\$?\\w*:\\$?\\w*")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Custom Tag" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\"|&quot;|&#34;)"+                              , reCompiled = Just (compileRegex False "(\"|&quot;|&#34;)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Html Double Quoted Value" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "('|&#39;)"+                              , reCompiled = Just (compileRegex False "('|&#39;)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Html Single Quoted Value" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*#?-?_?\\.?[a-zA-Z0-9]*"+                              , reCompiled =+                                  Just (compileRegex False "\\s*#?-?_?\\.?[a-zA-Z0-9]*")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Html Unquoted Value" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\/?>"+                              , reCompiled = Just (compileRegex False "\\/?>")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Java Multi-Line Comment"+          , Context+              { cName = "Java Multi-Line Comment"+              , cSyntax = "JSP"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Java Single-Line Comment"+          , Context+              { cName = "Java Single-Line Comment"+              , cSyntax = "JSP"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Java String"+          , Context+              { cName = "Java String"+              , cSyntax = "JSP"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Jsp Comment"+          , Context+              { cName = "Jsp Comment"+              , cSyntax = "JSP"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "--%>"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Jsp Custom Tag"+          , Context+              { cName = "Jsp Custom Tag"+              , cSyntax = "JSP"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\/?>"+                              , reCompiled = Just (compileRegex False "\\/?>")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*=\\s*"+                              , reCompiled = Just (compileRegex False "\\s*=\\s*")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Custom Tag Value" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<%--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%(!|=)?"+                              , reCompiled = Just (compileRegex False "<%(!|=)?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Scriptlet" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Expression" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Jsp Custom Tag Value"+          , Context+              { cName = "Jsp Custom Tag Value"+              , cSyntax = "JSP"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<%--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%(!|=)?"+                              , reCompiled = Just (compileRegex False "<%(!|=)?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Scriptlet" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Expression" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "JSP" , "Jsp Double Quoted Custom Tag Value" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "JSP" , "Jsp Single Quoted Custom Tag Value" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\/?>"+                              , reCompiled = Just (compileRegex False "\\/?>")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Jsp Double Quoted Custom Tag Value"+          , Context+              { cName = "Jsp Double Quoted Custom Tag Value"+              , cSyntax = "JSP"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<%--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%(!|=)?"+                              , reCompiled = Just (compileRegex False "<%(!|=)?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Scriptlet" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Expression" ) ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Jsp Double Quoted Param Value"+          , Context+              { cName = "Jsp Double Quoted Param Value"+              , cSyntax = "JSP"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<%--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%(!|=)?"+                              , reCompiled = Just (compileRegex False "<%(!|=)?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Scriptlet" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Expression" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Jsp Expression"+          , Context+              { cName = "Jsp Expression"+              , cSyntax = "JSP"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "'${'"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "abstract"+                               , "assert"+                               , "break"+                               , "case"+                               , "catch"+                               , "class"+                               , "continue"+                               , "default"+                               , "do"+                               , "else"+                               , "extends"+                               , "false"+                               , "finally"+                               , "for"+                               , "goto"+                               , "if"+                               , "implements"+                               , "import"+                               , "instanceof"+                               , "interface"+                               , "native"+                               , "new"+                               , "null"+                               , "package"+                               , "private"+                               , "protected"+                               , "public"+                               , "return"+                               , "strictfp"+                               , "super"+                               , "switch"+                               , "synchronized"+                               , "this"+                               , "throw"+                               , "throws"+                               , "transient"+                               , "true"+                               , "try"+                               , "volatile"+                               , "while"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "and"+                               , "div"+                               , "empty"+                               , "eq"+                               , "false"+                               , "ge"+                               , "gt"+                               , "instanceof"+                               , "le"+                               , "lt"+                               , "mod"+                               , "ne"+                               , "not"+                               , "null"+                               , "or"+                               , "true"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "boolean"+                               , "byte"+                               , "char"+                               , "const"+                               , "double"+                               , "final"+                               , "float"+                               , "int"+                               , "long"+                               , "short"+                               , "static"+                               , "void"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ARG_IN"+                               , "ARG_INOUT"+                               , "ARG_OUT"+                               , "AWTError"+                               , "AWTEvent"+                               , "AWTEventListener"+                               , "AWTEventListenerProxy"+                               , "AWTEventMulticaster"+                               , "AWTException"+                               , "AWTKeyStroke"+                               , "AWTPermission"+                               , "AbstractAction"+                               , "AbstractBorder"+                               , "AbstractButton"+                               , "AbstractCellEditor"+                               , "AbstractCollection"+                               , "AbstractColorChooserPanel"+                               , "AbstractDocument"+                               , "AbstractFormatter"+                               , "AbstractFormatterFactory"+                               , "AbstractInterruptibleChannel"+                               , "AbstractLayoutCache"+                               , "AbstractList"+                               , "AbstractListModel"+                               , "AbstractMap"+                               , "AbstractMethodError"+                               , "AbstractPreferences"+                               , "AbstractSelectableChannel"+                               , "AbstractSelectionKey"+                               , "AbstractSelector"+                               , "AbstractSequentialList"+                               , "AbstractSet"+                               , "AbstractSpinnerModel"+                               , "AbstractTableModel"+                               , "AbstractUndoableEdit"+                               , "AbstractWriter"+                               , "AccessControlContext"+                               , "AccessControlException"+                               , "AccessController"+                               , "AccessException"+                               , "Accessible"+                               , "AccessibleAction"+                               , "AccessibleBundle"+                               , "AccessibleComponent"+                               , "AccessibleContext"+                               , "AccessibleEditableText"+                               , "AccessibleExtendedComponent"+                               , "AccessibleExtendedTable"+                               , "AccessibleHyperlink"+                               , "AccessibleHypertext"+                               , "AccessibleIcon"+                               , "AccessibleKeyBinding"+                               , "AccessibleObject"+                               , "AccessibleRelation"+                               , "AccessibleRelationSet"+                               , "AccessibleResourceBundle"+                               , "AccessibleRole"+                               , "AccessibleSelection"+                               , "AccessibleState"+                               , "AccessibleStateSet"+                               , "AccessibleTable"+                               , "AccessibleTableModelChange"+                               , "AccessibleText"+                               , "AccessibleValue"+                               , "AccountExpiredException"+                               , "Acl"+                               , "AclEntry"+                               , "AclNotFoundException"+                               , "Action"+                               , "ActionEvent"+                               , "ActionListener"+                               , "ActionMap"+                               , "ActionMapUIResource"+                               , "Activatable"+                               , "ActivateFailedException"+                               , "ActivationDesc"+                               , "ActivationException"+                               , "ActivationGroup"+                               , "ActivationGroupDesc"+                               , "ActivationGroupID"+                               , "ActivationGroup_Stub"+                               , "ActivationID"+                               , "ActivationInstantiator"+                               , "ActivationMonitor"+                               , "ActivationSystem"+                               , "Activator"+                               , "ActiveEvent"+                               , "ActiveValue"+                               , "AdapterActivator"+                               , "AdapterActivatorOperations"+                               , "AdapterAlreadyExists"+                               , "AdapterAlreadyExistsHelper"+                               , "AdapterInactive"+                               , "AdapterInactiveHelper"+                               , "AdapterNonExistent"+                               , "AdapterNonExistentHelper"+                               , "AddressHelper"+                               , "Adjustable"+                               , "AdjustmentEvent"+                               , "AdjustmentListener"+                               , "Adler32"+                               , "AffineTransform"+                               , "AffineTransformOp"+                               , "AlgorithmParameterGenerator"+                               , "AlgorithmParameterGeneratorSpi"+                               , "AlgorithmParameterSpec"+                               , "AlgorithmParameters"+                               , "AlgorithmParametersSpi"+                               , "AlignmentAction"+                               , "AllPermission"+                               , "AlphaComposite"+                               , "AlreadyBound"+                               , "AlreadyBoundException"+                               , "AlreadyBoundHelper"+                               , "AlreadyBoundHolder"+                               , "AlreadyConnectedException"+                               , "AncestorEvent"+                               , "AncestorListener"+                               , "Annotation"+                               , "Any"+                               , "AnyHolder"+                               , "AnySeqHelper"+                               , "AnySeqHolder"+                               , "AppConfigurationEntry"+                               , "Applet"+                               , "AppletContext"+                               , "AppletInitializer"+                               , "AppletStub"+                               , "ApplicationException"+                               , "Arc2D"+                               , "Area"+                               , "AreaAveragingScaleFilter"+                               , "ArithmeticException"+                               , "Array"+                               , "ArrayIndexOutOfBoundsException"+                               , "ArrayList"+                               , "ArrayStoreException"+                               , "Arrays"+                               , "AssertionError"+                               , "AsyncBoxView"+                               , "AsynchronousCloseException"+                               , "Attr"+                               , "Attribute"+                               , "AttributeContext"+                               , "AttributeException"+                               , "AttributeInUseException"+                               , "AttributeList"+                               , "AttributeListImpl"+                               , "AttributeModificationException"+                               , "AttributeSet"+                               , "AttributeSetUtilities"+                               , "AttributeUndoableEdit"+                               , "AttributedCharacterIterator"+                               , "AttributedString"+                               , "Attributes"+                               , "AttributesImpl"+                               , "AudioClip"+                               , "AudioFileFormat"+                               , "AudioFileReader"+                               , "AudioFileWriter"+                               , "AudioFormat"+                               , "AudioInputStream"+                               , "AudioPermission"+                               , "AudioSystem"+                               , "AuthPermission"+                               , "AuthenticationException"+                               , "AuthenticationNotSupportedException"+                               , "Authenticator"+                               , "Autoscroll"+                               , "BAD_CONTEXT"+                               , "BAD_INV_ORDER"+                               , "BAD_OPERATION"+                               , "BAD_PARAM"+                               , "BAD_POLICY"+                               , "BAD_POLICY_TYPE"+                               , "BAD_POLICY_VALUE"+                               , "BAD_TYPECODE"+                               , "BCSIterator"+                               , "BCSSServiceProvider"+                               , "BYTE_ARRAY"+                               , "BackingStoreException"+                               , "BadKind"+                               , "BadLocationException"+                               , "BadPaddingException"+                               , "BandCombineOp"+                               , "BandedSampleModel"+                               , "BasicArrowButton"+                               , "BasicAttribute"+                               , "BasicAttributes"+                               , "BasicBorders"+                               , "BasicButtonListener"+                               , "BasicButtonUI"+                               , "BasicCaret"+                               , "BasicCheckBoxMenuItemUI"+                               , "BasicCheckBoxUI"+                               , "BasicColorChooserUI"+                               , "BasicComboBoxEditor"+                               , "BasicComboBoxRenderer"+                               , "BasicComboBoxUI"+                               , "BasicComboPopup"+                               , "BasicDesktopIconUI"+                               , "BasicDesktopPaneUI"+                               , "BasicDirectoryModel"+                               , "BasicEditorPaneUI"+                               , "BasicFileChooserUI"+                               , "BasicFormattedTextFieldUI"+                               , "BasicGraphicsUtils"+                               , "BasicHTML"+                               , "BasicHighlighter"+                               , "BasicIconFactory"+                               , "BasicInternalFrameTitlePane"+                               , "BasicInternalFrameUI"+                               , "BasicLabelUI"+                               , "BasicListUI"+                               , "BasicLookAndFeel"+                               , "BasicMenuBarUI"+                               , "BasicMenuItemUI"+                               , "BasicMenuUI"+                               , "BasicOptionPaneUI"+                               , "BasicPanelUI"+                               , "BasicPasswordFieldUI"+                               , "BasicPermission"+                               , "BasicPopupMenuSeparatorUI"+                               , "BasicPopupMenuUI"+                               , "BasicProgressBarUI"+                               , "BasicRadioButtonMenuItemUI"+                               , "BasicRadioButtonUI"+                               , "BasicRootPaneUI"+                               , "BasicScrollBarUI"+                               , "BasicScrollPaneUI"+                               , "BasicSeparatorUI"+                               , "BasicSliderUI"+                               , "BasicSpinnerUI"+                               , "BasicSplitPaneDivider"+                               , "BasicSplitPaneUI"+                               , "BasicStroke"+                               , "BasicTabbedPaneUI"+                               , "BasicTableHeaderUI"+                               , "BasicTableUI"+                               , "BasicTextAreaUI"+                               , "BasicTextFieldUI"+                               , "BasicTextPaneUI"+                               , "BasicTextUI"+                               , "BasicToggleButtonUI"+                               , "BasicToolBarSeparatorUI"+                               , "BasicToolBarUI"+                               , "BasicToolTipUI"+                               , "BasicTreeUI"+                               , "BasicViewportUI"+                               , "BatchUpdateException"+                               , "BeanContext"+                               , "BeanContextChild"+                               , "BeanContextChildComponentProxy"+                               , "BeanContextChildSupport"+                               , "BeanContextContainerProxy"+                               , "BeanContextEvent"+                               , "BeanContextMembershipEvent"+                               , "BeanContextMembershipListener"+                               , "BeanContextProxy"+                               , "BeanContextServiceAvailableEvent"+                               , "BeanContextServiceProvider"+                               , "BeanContextServiceProviderBeanInfo"+                               , "BeanContextServiceRevokedEvent"+                               , "BeanContextServiceRevokedListener"+                               , "BeanContextServices"+                               , "BeanContextServicesListener"+                               , "BeanContextServicesSupport"+                               , "BeanContextSupport"+                               , "BeanDescriptor"+                               , "BeanInfo"+                               , "Beans"+                               , "BeepAction"+                               , "BevelBorder"+                               , "BevelBorderUIResource"+                               , "Bias"+                               , "Bidi"+                               , "BigDecimal"+                               , "BigInteger"+                               , "BinaryRefAddr"+                               , "BindException"+                               , "Binding"+                               , "BindingHelper"+                               , "BindingHolder"+                               , "BindingIterator"+                               , "BindingIteratorHelper"+                               , "BindingIteratorHolder"+                               , "BindingIteratorOperations"+                               , "BindingIteratorPOA"+                               , "BindingListHelper"+                               , "BindingListHolder"+                               , "BindingType"+                               , "BindingTypeHelper"+                               , "BindingTypeHolder"+                               , "BitSet"+                               , "Blob"+                               , "BlockView"+                               , "BoldAction"+                               , "Book"+                               , "Boolean"+                               , "BooleanControl"+                               , "BooleanHolder"+                               , "BooleanSeqHelper"+                               , "BooleanSeqHolder"+                               , "Border"+                               , "BorderFactory"+                               , "BorderLayout"+                               , "BorderUIResource"+                               , "BoundedRangeModel"+                               , "Bounds"+                               , "Box"+                               , "BoxLayout"+                               , "BoxPainter"+                               , "BoxView"+                               , "BoxedValueHelper"+                               , "BreakIterator"+                               , "Buffer"+                               , "BufferCapabilities"+                               , "BufferOverflowException"+                               , "BufferStrategy"+                               , "BufferUnderflowException"+                               , "BufferedImage"+                               , "BufferedImageFilter"+                               , "BufferedImageOp"+                               , "BufferedInputStream"+                               , "BufferedOutputStream"+                               , "BufferedReader"+                               , "BufferedWriter"+                               , "Button"+                               , "ButtonAreaLayout"+                               , "ButtonBorder"+                               , "ButtonGroup"+                               , "ButtonModel"+                               , "ButtonUI"+                               , "Byte"+                               , "ByteArrayInputStream"+                               , "ByteArrayOutputStream"+                               , "ByteBuffer"+                               , "ByteChannel"+                               , "ByteHolder"+                               , "ByteLookupTable"+                               , "ByteOrder"+                               , "CDATASection"+                               , "CHAR_ARRAY"+                               , "CMMException"+                               , "COMM_FAILURE"+                               , "CRC32"+                               , "CRL"+                               , "CRLException"+                               , "CRLSelector"+                               , "CSS"+                               , "CTX_RESTRICT_SCOPE"+                               , "Calendar"+                               , "CallableStatement"+                               , "Callback"+                               , "CallbackHandler"+                               , "CancelablePrintJob"+                               , "CancelledKeyException"+                               , "CannotProceed"+                               , "CannotProceedException"+                               , "CannotProceedHelper"+                               , "CannotProceedHolder"+                               , "CannotRedoException"+                               , "CannotUndoException"+                               , "Canvas"+                               , "CardLayout"+                               , "Caret"+                               , "CaretEvent"+                               , "CaretListener"+                               , "CaretPolicy"+                               , "CellEditor"+                               , "CellEditorListener"+                               , "CellRendererPane"+                               , "CertPath"+                               , "CertPathBuilder"+                               , "CertPathBuilderException"+                               , "CertPathBuilderResult"+                               , "CertPathBuilderSpi"+                               , "CertPathParameters"+                               , "CertPathRep"+                               , "CertPathValidator"+                               , "CertPathValidatorException"+                               , "CertPathValidatorResult"+                               , "CertPathValidatorSpi"+                               , "CertSelector"+                               , "CertStore"+                               , "CertStoreException"+                               , "CertStoreParameters"+                               , "CertStoreSpi"+                               , "Certificate"+                               , "CertificateEncodingException"+                               , "CertificateException"+                               , "CertificateExpiredException"+                               , "CertificateFactory"+                               , "CertificateFactorySpi"+                               , "CertificateNotYetValidException"+                               , "CertificateParsingException"+                               , "CertificateRep"+                               , "ChangeEvent"+                               , "ChangeListener"+                               , "ChangedCharSetException"+                               , "Channel"+                               , "ChannelBinding"+                               , "Channels"+                               , "CharArrayReader"+                               , "CharArrayWriter"+                               , "CharBuffer"+                               , "CharConversionException"+                               , "CharHolder"+                               , "CharSeqHelper"+                               , "CharSeqHolder"+                               , "CharSequence"+                               , "Character"+                               , "CharacterAttribute"+                               , "CharacterCodingException"+                               , "CharacterConstants"+                               , "CharacterData"+                               , "CharacterIterator"+                               , "Charset"+                               , "CharsetDecoder"+                               , "CharsetEncoder"+                               , "CharsetProvider"+                               , "Checkbox"+                               , "CheckboxGroup"+                               , "CheckboxMenuItem"+                               , "CheckedInputStream"+                               , "CheckedOutputStream"+                               , "Checksum"+                               , "Choice"+                               , "ChoiceCallback"+                               , "ChoiceFormat"+                               , "Chromaticity"+                               , "Cipher"+                               , "CipherInputStream"+                               , "CipherOutputStream"+                               , "CipherSpi"+                               , "Class"+                               , "ClassCastException"+                               , "ClassCircularityError"+                               , "ClassDesc"+                               , "ClassFormatError"+                               , "ClassLoader"+                               , "ClassNotFoundException"+                               , "ClientRequestInfo"+                               , "ClientRequestInfoOperations"+                               , "ClientRequestInterceptor"+                               , "ClientRequestInterceptorOperations"+                               , "Clip"+                               , "Clipboard"+                               , "ClipboardOwner"+                               , "Clob"+                               , "CloneNotSupportedException"+                               , "Cloneable"+                               , "ClosedByInterruptException"+                               , "ClosedChannelException"+                               , "ClosedSelectorException"+                               , "CodeSets"+                               , "CodeSource"+                               , "Codec"+                               , "CodecFactory"+                               , "CodecFactoryHelper"+                               , "CodecFactoryOperations"+                               , "CodecOperations"+                               , "CoderMalfunctionError"+                               , "CoderResult"+                               , "CodingErrorAction"+                               , "CollationElementIterator"+                               , "CollationKey"+                               , "Collator"+                               , "Collection"+                               , "CollectionCertStoreParameters"+                               , "Collections"+                               , "Color"+                               , "ColorAttribute"+                               , "ColorChooserComponentFactory"+                               , "ColorChooserUI"+                               , "ColorConstants"+                               , "ColorConvertOp"+                               , "ColorModel"+                               , "ColorSelectionModel"+                               , "ColorSpace"+                               , "ColorSupported"+                               , "ColorType"+                               , "ColorUIResource"+                               , "ComboBoxEditor"+                               , "ComboBoxModel"+                               , "ComboBoxUI"+                               , "ComboPopup"+                               , "CommandEnvironment"+                               , "Comment"+                               , "CommunicationException"+                               , "Comparable"+                               , "Comparator"+                               , "Compiler"+                               , "CompletionStatus"+                               , "CompletionStatusHelper"+                               , "Component"+                               , "ComponentAdapter"+                               , "ComponentColorModel"+                               , "ComponentEvent"+                               , "ComponentIdHelper"+                               , "ComponentInputMap"+                               , "ComponentInputMapUIResource"+                               , "ComponentListener"+                               , "ComponentOrientation"+                               , "ComponentSampleModel"+                               , "ComponentUI"+                               , "ComponentView"+                               , "Composite"+                               , "CompositeContext"+                               , "CompositeName"+                               , "CompositeView"+                               , "CompoundBorder"+                               , "CompoundBorderUIResource"+                               , "CompoundControl"+                               , "CompoundEdit"+                               , "CompoundName"+                               , "Compression"+                               , "ConcurrentModificationException"+                               , "Configuration"+                               , "ConfigurationException"+                               , "ConfirmationCallback"+                               , "ConnectException"+                               , "ConnectIOException"+                               , "Connection"+                               , "ConnectionEvent"+                               , "ConnectionEventListener"+                               , "ConnectionPendingException"+                               , "ConnectionPoolDataSource"+                               , "ConsoleHandler"+                               , "Constraints"+                               , "Constructor"+                               , "Container"+                               , "ContainerAdapter"+                               , "ContainerEvent"+                               , "ContainerListener"+                               , "ContainerOrderFocusTraversalPolicy"+                               , "Content"+                               , "ContentHandler"+                               , "ContentHandlerFactory"+                               , "ContentModel"+                               , "Context"+                               , "ContextList"+                               , "ContextNotEmptyException"+                               , "ContextualRenderedImageFactory"+                               , "Control"+                               , "ControlFactory"+                               , "ControllerEventListener"+                               , "ConvolveOp"+                               , "CookieHolder"+                               , "Copies"+                               , "CopiesSupported"+                               , "CopyAction"+                               , "CredentialExpiredException"+                               , "CropImageFilter"+                               , "CubicCurve2D"+                               , "Currency"+                               , "Current"+                               , "CurrentHelper"+                               , "CurrentHolder"+                               , "CurrentOperations"+                               , "Cursor"+                               , "CustomMarshal"+                               , "CustomValue"+                               , "Customizer"+                               , "CutAction"+                               , "DATA_CONVERSION"+                               , "DESKeySpec"+                               , "DESedeKeySpec"+                               , "DGC"+                               , "DHGenParameterSpec"+                               , "DHKey"+                               , "DHParameterSpec"+                               , "DHPrivateKey"+                               , "DHPrivateKeySpec"+                               , "DHPublicKey"+                               , "DHPublicKeySpec"+                               , "DOMException"+                               , "DOMImplementation"+                               , "DOMLocator"+                               , "DOMResult"+                               , "DOMSource"+                               , "DSAKey"+                               , "DSAKeyPairGenerator"+                               , "DSAParameterSpec"+                               , "DSAParams"+                               , "DSAPrivateKey"+                               , "DSAPrivateKeySpec"+                               , "DSAPublicKey"+                               , "DSAPublicKeySpec"+                               , "DTD"+                               , "DTDConstants"+                               , "DTDHandler"+                               , "DataBuffer"+                               , "DataBufferByte"+                               , "DataBufferDouble"+                               , "DataBufferFloat"+                               , "DataBufferInt"+                               , "DataBufferShort"+                               , "DataBufferUShort"+                               , "DataFlavor"+                               , "DataFormatException"+                               , "DataInput"+                               , "DataInputStream"+                               , "DataLine"+                               , "DataOutput"+                               , "DataOutputStream"+                               , "DataSource"+                               , "DataTruncation"+                               , "DatabaseMetaData"+                               , "DatagramChannel"+                               , "DatagramPacket"+                               , "DatagramSocket"+                               , "DatagramSocketImpl"+                               , "DatagramSocketImplFactory"+                               , "Date"+                               , "DateEditor"+                               , "DateFormat"+                               , "DateFormatSymbols"+                               , "DateFormatter"+                               , "DateTimeAtCompleted"+                               , "DateTimeAtCreation"+                               , "DateTimeAtProcessing"+                               , "DateTimeSyntax"+                               , "DebugGraphics"+                               , "DecimalFormat"+                               , "DecimalFormatSymbols"+                               , "DeclHandler"+                               , "DefaultBoundedRangeModel"+                               , "DefaultButtonModel"+                               , "DefaultCaret"+                               , "DefaultCellEditor"+                               , "DefaultColorSelectionModel"+                               , "DefaultComboBoxModel"+                               , "DefaultDesktopManager"+                               , "DefaultEditor"+                               , "DefaultEditorKit"+                               , "DefaultFocusManager"+                               , "DefaultFocusTraversalPolicy"+                               , "DefaultFormatter"+                               , "DefaultFormatterFactory"+                               , "DefaultHandler"+                               , "DefaultHighlightPainter"+                               , "DefaultHighlighter"+                               , "DefaultKeyTypedAction"+                               , "DefaultKeyboardFocusManager"+                               , "DefaultListCellRenderer"+                               , "DefaultListModel"+                               , "DefaultListSelectionModel"+                               , "DefaultMenuLayout"+                               , "DefaultMetalTheme"+                               , "DefaultMutableTreeNode"+                               , "DefaultPersistenceDelegate"+                               , "DefaultSelectionType"+                               , "DefaultSingleSelectionModel"+                               , "DefaultStyledDocument"+                               , "DefaultTableCellRenderer"+                               , "DefaultTableColumnModel"+                               , "DefaultTableModel"+                               , "DefaultTextUI"+                               , "DefaultTreeCellEditor"+                               , "DefaultTreeCellRenderer"+                               , "DefaultTreeModel"+                               , "DefaultTreeSelectionModel"+                               , "DefinitionKind"+                               , "DefinitionKindHelper"+                               , "Deflater"+                               , "DeflaterOutputStream"+                               , "Delegate"+                               , "DelegationPermission"+                               , "DesignMode"+                               , "DesktopIconUI"+                               , "DesktopManager"+                               , "DesktopPaneUI"+                               , "Destination"+                               , "DestinationType"+                               , "DestroyFailedException"+                               , "Destroyable"+                               , "Dialog"+                               , "DialogType"+                               , "Dictionary"+                               , "DigestException"+                               , "DigestInputStream"+                               , "DigestOutputStream"+                               , "Dimension"+                               , "Dimension2D"+                               , "DimensionUIResource"+                               , "DirContext"+                               , "DirObjectFactory"+                               , "DirStateFactory"+                               , "DirectColorModel"+                               , "DirectoryManager"+                               , "DisplayMode"+                               , "DnDConstants"+                               , "Doc"+                               , "DocAttribute"+                               , "DocAttributeSet"+                               , "DocFlavor"+                               , "DocPrintJob"+                               , "Document"+                               , "DocumentBuilder"+                               , "DocumentBuilderFactory"+                               , "DocumentEvent"+                               , "DocumentFilter"+                               , "DocumentFragment"+                               , "DocumentHandler"+                               , "DocumentListener"+                               , "DocumentName"+                               , "DocumentParser"+                               , "DocumentType"+                               , "DomainCombiner"+                               , "DomainManager"+                               , "DomainManagerOperations"+                               , "Double"+                               , "DoubleBuffer"+                               , "DoubleHolder"+                               , "DoubleSeqHelper"+                               , "DoubleSeqHolder"+                               , "DragGestureEvent"+                               , "DragGestureListener"+                               , "DragGestureRecognizer"+                               , "DragSource"+                               , "DragSourceAdapter"+                               , "DragSourceContext"+                               , "DragSourceDragEvent"+                               , "DragSourceDropEvent"+                               , "DragSourceEvent"+                               , "DragSourceListener"+                               , "DragSourceMotionListener"+                               , "Driver"+                               , "DriverManager"+                               , "DriverPropertyInfo"+                               , "DropTarget"+                               , "DropTargetAdapter"+                               , "DropTargetAutoScroller"+                               , "DropTargetContext"+                               , "DropTargetDragEvent"+                               , "DropTargetDropEvent"+                               , "DropTargetEvent"+                               , "DropTargetListener"+                               , "DuplicateName"+                               , "DuplicateNameHelper"+                               , "DynAny"+                               , "DynAnyFactory"+                               , "DynAnyFactoryHelper"+                               , "DynAnyFactoryOperations"+                               , "DynAnyHelper"+                               , "DynAnyOperations"+                               , "DynAnySeqHelper"+                               , "DynArray"+                               , "DynArrayHelper"+                               , "DynArrayOperations"+                               , "DynEnum"+                               , "DynEnumHelper"+                               , "DynEnumOperations"+                               , "DynFixed"+                               , "DynFixedHelper"+                               , "DynFixedOperations"+                               , "DynSequence"+                               , "DynSequenceHelper"+                               , "DynSequenceOperations"+                               , "DynStruct"+                               , "DynStructHelper"+                               , "DynStructOperations"+                               , "DynUnion"+                               , "DynUnionHelper"+                               , "DynUnionOperations"+                               , "DynValue"+                               , "DynValueBox"+                               , "DynValueBoxOperations"+                               , "DynValueCommon"+                               , "DynValueCommonOperations"+                               , "DynValueHelper"+                               , "DynValueOperations"+                               , "DynamicImplementation"+                               , "DynamicUtilTreeNode"+                               , "ENCODING_CDR_ENCAPS"+                               , "EOFException"+                               , "EditorKit"+                               , "Element"+                               , "ElementChange"+                               , "ElementEdit"+                               , "ElementIterator"+                               , "ElementSpec"+                               , "Ellipse2D"+                               , "EmptyBorder"+                               , "EmptyBorderUIResource"+                               , "EmptySelectionModel"+                               , "EmptyStackException"+                               , "EncodedKeySpec"+                               , "Encoder"+                               , "Encoding"+                               , "EncryptedPrivateKeyInfo"+                               , "Engineering"+                               , "Entity"+                               , "EntityReference"+                               , "EntityResolver"+                               , "Entry"+                               , "EnumControl"+                               , "EnumSyntax"+                               , "Enumeration"+                               , "Environment"+                               , "Error"+                               , "ErrorHandler"+                               , "ErrorListener"+                               , "ErrorManager"+                               , "EtchedBorder"+                               , "EtchedBorderUIResource"+                               , "Event"+                               , "EventContext"+                               , "EventDirContext"+                               , "EventHandler"+                               , "EventListener"+                               , "EventListenerList"+                               , "EventListenerProxy"+                               , "EventObject"+                               , "EventQueue"+                               , "EventSetDescriptor"+                               , "EventType"+                               , "Exception"+                               , "ExceptionInInitializerError"+                               , "ExceptionList"+                               , "ExceptionListener"+                               , "ExemptionMechanism"+                               , "ExemptionMechanismException"+                               , "ExemptionMechanismSpi"+                               , "ExpandVetoException"+                               , "ExportException"+                               , "Expression"+                               , "ExtendedRequest"+                               , "ExtendedResponse"+                               , "Externalizable"+                               , "FREE_MEM"+                               , "FactoryConfigurationError"+                               , "FailedLoginException"+                               , "FeatureDescriptor"+                               , "Fidelity"+                               , "Field"+                               , "FieldBorder"+                               , "FieldNameHelper"+                               , "FieldPosition"+                               , "FieldView"+                               , "File"+                               , "FileCacheImageInputStream"+                               , "FileCacheImageOutputStream"+                               , "FileChannel"+                               , "FileChooserUI"+                               , "FileDescriptor"+                               , "FileDialog"+                               , "FileFilter"+                               , "FileHandler"+                               , "FileIcon16"+                               , "FileImageInputStream"+                               , "FileImageOutputStream"+                               , "FileInputStream"+                               , "FileLock"+                               , "FileLockInterruptionException"+                               , "FileNameMap"+                               , "FileNotFoundException"+                               , "FileOutputStream"+                               , "FilePermission"+                               , "FileReader"+                               , "FileSystemView"+                               , "FileView"+                               , "FileWriter"+                               , "FilenameFilter"+                               , "Filler"+                               , "Filter"+                               , "FilterBypass"+                               , "FilterInputStream"+                               , "FilterOutputStream"+                               , "FilterReader"+                               , "FilterWriter"+                               , "FilteredImageSource"+                               , "Finishings"+                               , "FixedHeightLayoutCache"+                               , "FixedHolder"+                               , "FlatteningPathIterator"+                               , "FlavorException"+                               , "FlavorMap"+                               , "FlavorTable"+                               , "FlipContents"+                               , "Float"+                               , "FloatBuffer"+                               , "FloatControl"+                               , "FloatHolder"+                               , "FloatSeqHelper"+                               , "FloatSeqHolder"+                               , "FlowLayout"+                               , "FlowStrategy"+                               , "FlowView"+                               , "Flush3DBorder"+                               , "FocusAdapter"+                               , "FocusEvent"+                               , "FocusListener"+                               , "FocusManager"+                               , "FocusTraversalPolicy"+                               , "FolderIcon16"+                               , "Font"+                               , "FontAttribute"+                               , "FontConstants"+                               , "FontFamilyAction"+                               , "FontFormatException"+                               , "FontMetrics"+                               , "FontRenderContext"+                               , "FontSizeAction"+                               , "FontUIResource"+                               , "ForegroundAction"+                               , "FormView"+                               , "Format"+                               , "FormatConversionProvider"+                               , "FormatMismatch"+                               , "FormatMismatchHelper"+                               , "Formatter"+                               , "ForwardRequest"+                               , "ForwardRequestHelper"+                               , "Frame"+                               , "GSSContext"+                               , "GSSCredential"+                               , "GSSException"+                               , "GSSManager"+                               , "GSSName"+                               , "GZIPInputStream"+                               , "GZIPOutputStream"+                               , "GapContent"+                               , "GatheringByteChannel"+                               , "GeneralPath"+                               , "GeneralSecurityException"+                               , "GetField"+                               , "GlyphJustificationInfo"+                               , "GlyphMetrics"+                               , "GlyphPainter"+                               , "GlyphVector"+                               , "GlyphView"+                               , "GradientPaint"+                               , "GraphicAttribute"+                               , "Graphics"+                               , "Graphics2D"+                               , "GraphicsConfigTemplate"+                               , "GraphicsConfiguration"+                               , "GraphicsDevice"+                               , "GraphicsEnvironment"+                               , "GrayFilter"+                               , "GregorianCalendar"+                               , "GridBagConstraints"+                               , "GridBagLayout"+                               , "GridLayout"+                               , "Group"+                               , "Guard"+                               , "GuardedObject"+                               , "HTML"+                               , "HTMLDocument"+                               , "HTMLEditorKit"+                               , "HTMLFrameHyperlinkEvent"+                               , "HTMLWriter"+                               , "Handler"+                               , "HandlerBase"+                               , "HandshakeCompletedEvent"+                               , "HandshakeCompletedListener"+                               , "HasControls"+                               , "HashAttributeSet"+                               , "HashDocAttributeSet"+                               , "HashMap"+                               , "HashPrintJobAttributeSet"+                               , "HashPrintRequestAttributeSet"+                               , "HashPrintServiceAttributeSet"+                               , "HashSet"+                               , "Hashtable"+                               , "HeadlessException"+                               , "HierarchyBoundsAdapter"+                               , "HierarchyBoundsListener"+                               , "HierarchyEvent"+                               , "HierarchyListener"+                               , "Highlight"+                               , "HighlightPainter"+                               , "Highlighter"+                               , "HostnameVerifier"+                               , "HttpURLConnection"+                               , "HttpsURLConnection"+                               , "HyperlinkEvent"+                               , "HyperlinkListener"+                               , "ICC_ColorSpace"+                               , "ICC_Profile"+                               , "ICC_ProfileGray"+                               , "ICC_ProfileRGB"+                               , "IDLEntity"+                               , "IDLType"+                               , "IDLTypeHelper"+                               , "IDLTypeOperations"+                               , "ID_ASSIGNMENT_POLICY_ID"+                               , "ID_UNIQUENESS_POLICY_ID"+                               , "IIOByteBuffer"+                               , "IIOException"+                               , "IIOImage"+                               , "IIOInvalidTreeException"+                               , "IIOMetadata"+                               , "IIOMetadataController"+                               , "IIOMetadataFormat"+                               , "IIOMetadataFormatImpl"+                               , "IIOMetadataNode"+                               , "IIOParam"+                               , "IIOParamController"+                               , "IIOReadProgressListener"+                               , "IIOReadUpdateListener"+                               , "IIOReadWarningListener"+                               , "IIORegistry"+                               , "IIOServiceProvider"+                               , "IIOWriteProgressListener"+                               , "IIOWriteWarningListener"+                               , "IMPLICIT_ACTIVATION_POLICY_ID"+                               , "IMP_LIMIT"+                               , "INITIALIZE"+                               , "INPUT_STREAM"+                               , "INTERNAL"+                               , "INTF_REPOS"+                               , "INVALID_TRANSACTION"+                               , "INV_FLAG"+                               , "INV_IDENT"+                               , "INV_OBJREF"+                               , "INV_POLICY"+                               , "IOException"+                               , "IOR"+                               , "IORHelper"+                               , "IORHolder"+                               , "IORInfo"+                               , "IORInfoOperations"+                               , "IORInterceptor"+                               , "IORInterceptorOperations"+                               , "IRObject"+                               , "IRObjectOperations"+                               , "ISO"+                               , "Icon"+                               , "IconUIResource"+                               , "IconView"+                               , "IdAssignmentPolicy"+                               , "IdAssignmentPolicyOperations"+                               , "IdAssignmentPolicyValue"+                               , "IdUniquenessPolicy"+                               , "IdUniquenessPolicyOperations"+                               , "IdUniquenessPolicyValue"+                               , "IdentifierHelper"+                               , "Identity"+                               , "IdentityHashMap"+                               , "IdentityScope"+                               , "IllegalAccessError"+                               , "IllegalAccessException"+                               , "IllegalArgumentException"+                               , "IllegalBlockSizeException"+                               , "IllegalBlockingModeException"+                               , "IllegalCharsetNameException"+                               , "IllegalComponentStateException"+                               , "IllegalMonitorStateException"+                               , "IllegalPathStateException"+                               , "IllegalSelectorException"+                               , "IllegalStateException"+                               , "IllegalThreadStateException"+                               , "Image"+                               , "ImageCapabilities"+                               , "ImageConsumer"+                               , "ImageFilter"+                               , "ImageGraphicAttribute"+                               , "ImageIO"+                               , "ImageIcon"+                               , "ImageInputStream"+                               , "ImageInputStreamImpl"+                               , "ImageInputStreamSpi"+                               , "ImageObserver"+                               , "ImageOutputStream"+                               , "ImageOutputStreamImpl"+                               , "ImageOutputStreamSpi"+                               , "ImageProducer"+                               , "ImageReadParam"+                               , "ImageReader"+                               , "ImageReaderSpi"+                               , "ImageReaderWriterSpi"+                               , "ImageTranscoder"+                               , "ImageTranscoderSpi"+                               , "ImageTypeSpecifier"+                               , "ImageView"+                               , "ImageWriteParam"+                               , "ImageWriter"+                               , "ImageWriterSpi"+                               , "ImagingOpException"+                               , "ImplicitActivationPolicy"+                               , "ImplicitActivationPolicyOperations"+                               , "ImplicitActivationPolicyValue"+                               , "IncompatibleClassChangeError"+                               , "InconsistentTypeCode"+                               , "InconsistentTypeCodeHelper"+                               , "IndexColorModel"+                               , "IndexOutOfBoundsException"+                               , "IndexedPropertyDescriptor"+                               , "IndirectionException"+                               , "Inet4Address"+                               , "Inet6Address"+                               , "InetAddress"+                               , "InetSocketAddress"+                               , "Inflater"+                               , "InflaterInputStream"+                               , "Info"+                               , "InheritableThreadLocal"+                               , "InitialContext"+                               , "InitialContextFactory"+                               , "InitialContextFactoryBuilder"+                               , "InitialDirContext"+                               , "InitialLdapContext"+                               , "InlineView"+                               , "InputContext"+                               , "InputEvent"+                               , "InputMap"+                               , "InputMapUIResource"+                               , "InputMethod"+                               , "InputMethodContext"+                               , "InputMethodDescriptor"+                               , "InputMethodEvent"+                               , "InputMethodHighlight"+                               , "InputMethodListener"+                               , "InputMethodRequests"+                               , "InputSource"+                               , "InputStream"+                               , "InputStreamReader"+                               , "InputSubset"+                               , "InputVerifier"+                               , "InsertBreakAction"+                               , "InsertContentAction"+                               , "InsertHTMLTextAction"+                               , "InsertTabAction"+                               , "Insets"+                               , "InsetsUIResource"+                               , "InstantiationError"+                               , "InstantiationException"+                               , "Instrument"+                               , "InsufficientResourcesException"+                               , "IntBuffer"+                               , "IntHolder"+                               , "Integer"+                               , "IntegerSyntax"+                               , "Interceptor"+                               , "InterceptorOperations"+                               , "InternalError"+                               , "InternalFrameAdapter"+                               , "InternalFrameBorder"+                               , "InternalFrameEvent"+                               , "InternalFrameFocusTraversalPolicy"+                               , "InternalFrameListener"+                               , "InternalFrameUI"+                               , "InternationalFormatter"+                               , "InterruptedException"+                               , "InterruptedIOException"+                               , "InterruptedNamingException"+                               , "InterruptibleChannel"+                               , "IntrospectionException"+                               , "Introspector"+                               , "Invalid"+                               , "InvalidAddress"+                               , "InvalidAddressHelper"+                               , "InvalidAddressHolder"+                               , "InvalidAlgorithmParameterException"+                               , "InvalidAttributeIdentifierException"+                               , "InvalidAttributeValueException"+                               , "InvalidAttributesException"+                               , "InvalidClassException"+                               , "InvalidDnDOperationException"+                               , "InvalidKeyException"+                               , "InvalidKeySpecException"+                               , "InvalidMarkException"+                               , "InvalidMidiDataException"+                               , "InvalidName"+                               , "InvalidNameException"+                               , "InvalidNameHelper"+                               , "InvalidNameHolder"+                               , "InvalidObjectException"+                               , "InvalidParameterException"+                               , "InvalidParameterSpecException"+                               , "InvalidPolicy"+                               , "InvalidPolicyHelper"+                               , "InvalidPreferencesFormatException"+                               , "InvalidSearchControlsException"+                               , "InvalidSearchFilterException"+                               , "InvalidSeq"+                               , "InvalidSlot"+                               , "InvalidSlotHelper"+                               , "InvalidTransactionException"+                               , "InvalidTypeForEncoding"+                               , "InvalidTypeForEncodingHelper"+                               , "InvalidValue"+                               , "InvalidValueHelper"+                               , "InvocationEvent"+                               , "InvocationHandler"+                               , "InvocationTargetException"+                               , "InvokeHandler"+                               , "IstringHelper"+                               , "ItalicAction"+                               , "ItemEvent"+                               , "ItemListener"+                               , "ItemSelectable"+                               , "Iterator"+                               , "IvParameterSpec"+                               , "JApplet"+                               , "JButton"+                               , "JCheckBox"+                               , "JCheckBoxMenuItem"+                               , "JColorChooser"+                               , "JComboBox"+                               , "JComponent"+                               , "JDesktopIcon"+                               , "JDesktopPane"+                               , "JDialog"+                               , "JEditorPane"+                               , "JFileChooser"+                               , "JFormattedTextField"+                               , "JFrame"+                               , "JIS"+                               , "JInternalFrame"+                               , "JLabel"+                               , "JLayeredPane"+                               , "JList"+                               , "JMenu"+                               , "JMenuBar"+                               , "JMenuItem"+                               , "JOptionPane"+                               , "JPEGHuffmanTable"+                               , "JPEGImageReadParam"+                               , "JPEGImageWriteParam"+                               , "JPEGQTable"+                               , "JPanel"+                               , "JPasswordField"+                               , "JPopupMenu"+                               , "JProgressBar"+                               , "JRadioButton"+                               , "JRadioButtonMenuItem"+                               , "JRootPane"+                               , "JScrollBar"+                               , "JScrollPane"+                               , "JSeparator"+                               , "JSlider"+                               , "JSpinner"+                               , "JSplitPane"+                               , "JTabbedPane"+                               , "JTable"+                               , "JTableHeader"+                               , "JTextArea"+                               , "JTextComponent"+                               , "JTextField"+                               , "JTextPane"+                               , "JToggleButton"+                               , "JToolBar"+                               , "JToolTip"+                               , "JTree"+                               , "JViewport"+                               , "JWindow"+                               , "JarEntry"+                               , "JarException"+                               , "JarFile"+                               , "JarInputStream"+                               , "JarOutputStream"+                               , "JarURLConnection"+                               , "JobAttributes"+                               , "JobHoldUntil"+                               , "JobImpressions"+                               , "JobImpressionsCompleted"+                               , "JobImpressionsSupported"+                               , "JobKOctets"+                               , "JobKOctetsProcessed"+                               , "JobKOctetsSupported"+                               , "JobMediaSheets"+                               , "JobMediaSheetsCompleted"+                               , "JobMediaSheetsSupported"+                               , "JobMessageFromOperator"+                               , "JobName"+                               , "JobOriginatingUserName"+                               , "JobPriority"+                               , "JobPrioritySupported"+                               , "JobSheets"+                               , "JobState"+                               , "JobStateReason"+                               , "JobStateReasons"+                               , "KerberosKey"+                               , "KerberosPrincipal"+                               , "KerberosTicket"+                               , "Kernel"+                               , "Key"+                               , "KeyAdapter"+                               , "KeyAgreement"+                               , "KeyAgreementSpi"+                               , "KeyBinding"+                               , "KeyEvent"+                               , "KeyEventDispatcher"+                               , "KeyEventPostProcessor"+                               , "KeyException"+                               , "KeyFactory"+                               , "KeyFactorySpi"+                               , "KeyGenerator"+                               , "KeyGeneratorSpi"+                               , "KeyListener"+                               , "KeyManagementException"+                               , "KeyManager"+                               , "KeyManagerFactory"+                               , "KeyManagerFactorySpi"+                               , "KeyPair"+                               , "KeyPairGenerator"+                               , "KeyPairGeneratorSpi"+                               , "KeySelectionManager"+                               , "KeySpec"+                               , "KeyStore"+                               , "KeyStoreException"+                               , "KeyStoreSpi"+                               , "KeyStroke"+                               , "KeyboardFocusManager"+                               , "Keymap"+                               , "LDAPCertStoreParameters"+                               , "LIFESPAN_POLICY_ID"+                               , "LOCATION_FORWARD"+                               , "Label"+                               , "LabelUI"+                               , "LabelView"+                               , "LanguageCallback"+                               , "LastOwnerException"+                               , "LayerPainter"+                               , "LayeredHighlighter"+                               , "LayoutFocusTraversalPolicy"+                               , "LayoutManager"+                               , "LayoutManager2"+                               , "LayoutQueue"+                               , "LazyInputMap"+                               , "LazyValue"+                               , "LdapContext"+                               , "LdapReferralException"+                               , "Lease"+                               , "Level"+                               , "LexicalHandler"+                               , "LifespanPolicy"+                               , "LifespanPolicyOperations"+                               , "LifespanPolicyValue"+                               , "LimitExceededException"+                               , "Line"+                               , "Line2D"+                               , "LineBorder"+                               , "LineBorderUIResource"+                               , "LineBreakMeasurer"+                               , "LineEvent"+                               , "LineListener"+                               , "LineMetrics"+                               , "LineNumberInputStream"+                               , "LineNumberReader"+                               , "LineUnavailableException"+                               , "LinkController"+                               , "LinkException"+                               , "LinkLoopException"+                               , "LinkRef"+                               , "LinkageError"+                               , "LinkedHashMap"+                               , "LinkedHashSet"+                               , "LinkedList"+                               , "List"+                               , "ListCellRenderer"+                               , "ListDataEvent"+                               , "ListDataListener"+                               , "ListEditor"+                               , "ListIterator"+                               , "ListModel"+                               , "ListPainter"+                               , "ListResourceBundle"+                               , "ListSelectionEvent"+                               , "ListSelectionListener"+                               , "ListSelectionModel"+                               , "ListUI"+                               , "ListView"+                               , "LoaderHandler"+                               , "LocalObject"+                               , "Locale"+                               , "LocateRegistry"+                               , "Locator"+                               , "LocatorImpl"+                               , "LogManager"+                               , "LogRecord"+                               , "LogStream"+                               , "Logger"+                               , "LoggingPermission"+                               , "LoginContext"+                               , "LoginException"+                               , "LoginModule"+                               , "LoginModuleControlFlag"+                               , "Long"+                               , "LongBuffer"+                               , "LongHolder"+                               , "LongLongSeqHelper"+                               , "LongLongSeqHolder"+                               , "LongSeqHelper"+                               , "LongSeqHolder"+                               , "LookAndFeel"+                               , "LookAndFeelInfo"+                               , "LookupOp"+                               , "LookupTable"+                               , "MARSHAL"+                               , "Mac"+                               , "MacSpi"+                               , "MalformedInputException"+                               , "MalformedLinkException"+                               , "MalformedURLException"+                               , "ManagerFactoryParameters"+                               , "Manifest"+                               , "Map"+                               , "MapMode"+                               , "MappedByteBuffer"+                               , "MarginBorder"+                               , "MarshalException"+                               , "MarshalledObject"+                               , "MaskFormatter"+                               , "Matcher"+                               , "Math"+                               , "MatteBorder"+                               , "MatteBorderUIResource"+                               , "Media"+                               , "MediaName"+                               , "MediaPrintableArea"+                               , "MediaSize"+                               , "MediaSizeName"+                               , "MediaTracker"+                               , "MediaTray"+                               , "MediaType"+                               , "Member"+                               , "MemoryCacheImageInputStream"+                               , "MemoryCacheImageOutputStream"+                               , "MemoryHandler"+                               , "MemoryImageSource"+                               , "Menu"+                               , "MenuBar"+                               , "MenuBarBorder"+                               , "MenuBarUI"+                               , "MenuComponent"+                               , "MenuContainer"+                               , "MenuDragMouseEvent"+                               , "MenuDragMouseListener"+                               , "MenuElement"+                               , "MenuEvent"+                               , "MenuItem"+                               , "MenuItemBorder"+                               , "MenuItemUI"+                               , "MenuKeyEvent"+                               , "MenuKeyListener"+                               , "MenuListener"+                               , "MenuSelectionManager"+                               , "MenuShortcut"+                               , "MessageDigest"+                               , "MessageDigestSpi"+                               , "MessageFormat"+                               , "MessageProp"+                               , "MetaEventListener"+                               , "MetaMessage"+                               , "MetalBorders"+                               , "MetalButtonUI"+                               , "MetalCheckBoxIcon"+                               , "MetalCheckBoxUI"+                               , "MetalComboBoxButton"+                               , "MetalComboBoxEditor"+                               , "MetalComboBoxIcon"+                               , "MetalComboBoxUI"+                               , "MetalDesktopIconUI"+                               , "MetalFileChooserUI"+                               , "MetalIconFactory"+                               , "MetalInternalFrameTitlePane"+                               , "MetalInternalFrameUI"+                               , "MetalLabelUI"+                               , "MetalLookAndFeel"+                               , "MetalPopupMenuSeparatorUI"+                               , "MetalProgressBarUI"+                               , "MetalRadioButtonUI"+                               , "MetalRootPaneUI"+                               , "MetalScrollBarUI"+                               , "MetalScrollButton"+                               , "MetalScrollPaneUI"+                               , "MetalSeparatorUI"+                               , "MetalSliderUI"+                               , "MetalSplitPaneUI"+                               , "MetalTabbedPaneUI"+                               , "MetalTextFieldUI"+                               , "MetalTheme"+                               , "MetalToggleButtonUI"+                               , "MetalToolBarUI"+                               , "MetalToolTipUI"+                               , "MetalTreeUI"+                               , "Method"+                               , "MethodDescriptor"+                               , "MidiChannel"+                               , "MidiDevice"+                               , "MidiDeviceProvider"+                               , "MidiEvent"+                               , "MidiFileFormat"+                               , "MidiFileReader"+                               , "MidiFileWriter"+                               , "MidiMessage"+                               , "MidiSystem"+                               , "MidiUnavailableException"+                               , "MimeTypeParseException"+                               , "MinimalHTMLWriter"+                               , "MissingResourceException"+                               , "Mixer"+                               , "MixerProvider"+                               , "ModificationItem"+                               , "Modifier"+                               , "MouseAdapter"+                               , "MouseDragGestureRecognizer"+                               , "MouseEvent"+                               , "MouseInputAdapter"+                               , "MouseInputListener"+                               , "MouseListener"+                               , "MouseMotionAdapter"+                               , "MouseMotionListener"+                               , "MouseWheelEvent"+                               , "MouseWheelListener"+                               , "MultiButtonUI"+                               , "MultiColorChooserUI"+                               , "MultiComboBoxUI"+                               , "MultiDesktopIconUI"+                               , "MultiDesktopPaneUI"+                               , "MultiDoc"+                               , "MultiDocPrintJob"+                               , "MultiDocPrintService"+                               , "MultiFileChooserUI"+                               , "MultiInternalFrameUI"+                               , "MultiLabelUI"+                               , "MultiListUI"+                               , "MultiLookAndFeel"+                               , "MultiMenuBarUI"+                               , "MultiMenuItemUI"+                               , "MultiOptionPaneUI"+                               , "MultiPanelUI"+                               , "MultiPixelPackedSampleModel"+                               , "MultiPopupMenuUI"+                               , "MultiProgressBarUI"+                               , "MultiRootPaneUI"+                               , "MultiScrollBarUI"+                               , "MultiScrollPaneUI"+                               , "MultiSeparatorUI"+                               , "MultiSliderUI"+                               , "MultiSpinnerUI"+                               , "MultiSplitPaneUI"+                               , "MultiTabbedPaneUI"+                               , "MultiTableHeaderUI"+                               , "MultiTableUI"+                               , "MultiTextUI"+                               , "MultiToolBarUI"+                               , "MultiToolTipUI"+                               , "MultiTreeUI"+                               , "MultiViewportUI"+                               , "MulticastSocket"+                               , "MultipleComponentProfileHelper"+                               , "MultipleComponentProfileHolder"+                               , "MultipleDocumentHandling"+                               , "MultipleDocumentHandlingType"+                               , "MultipleMaster"+                               , "MutableAttributeSet"+                               , "MutableComboBoxModel"+                               , "MutableTreeNode"+                               , "NA"+                               , "NO_IMPLEMENT"+                               , "NO_MEMORY"+                               , "NO_PERMISSION"+                               , "NO_RESOURCES"+                               , "NO_RESPONSE"+                               , "NVList"+                               , "Name"+                               , "NameAlreadyBoundException"+                               , "NameCallback"+                               , "NameClassPair"+                               , "NameComponent"+                               , "NameComponentHelper"+                               , "NameComponentHolder"+                               , "NameDynAnyPair"+                               , "NameDynAnyPairHelper"+                               , "NameDynAnyPairSeqHelper"+                               , "NameHelper"+                               , "NameHolder"+                               , "NameNotFoundException"+                               , "NameParser"+                               , "NameValuePair"+                               , "NameValuePairHelper"+                               , "NameValuePairSeqHelper"+                               , "NamedNodeMap"+                               , "NamedValue"+                               , "NamespaceChangeListener"+                               , "NamespaceSupport"+                               , "Naming"+                               , "NamingContext"+                               , "NamingContextExt"+                               , "NamingContextExtHelper"+                               , "NamingContextExtHolder"+                               , "NamingContextExtOperations"+                               , "NamingContextExtPOA"+                               , "NamingContextHelper"+                               , "NamingContextHolder"+                               , "NamingContextOperations"+                               , "NamingContextPOA"+                               , "NamingEnumeration"+                               , "NamingEvent"+                               , "NamingException"+                               , "NamingExceptionEvent"+                               , "NamingListener"+                               , "NamingManager"+                               , "NamingSecurityException"+                               , "NavigationFilter"+                               , "NegativeArraySizeException"+                               , "NetPermission"+                               , "NetworkInterface"+                               , "NoClassDefFoundError"+                               , "NoConnectionPendingException"+                               , "NoContext"+                               , "NoContextHelper"+                               , "NoInitialContextException"+                               , "NoPermissionException"+                               , "NoRouteToHostException"+                               , "NoServant"+                               , "NoServantHelper"+                               , "NoSuchAlgorithmException"+                               , "NoSuchAttributeException"+                               , "NoSuchElementException"+                               , "NoSuchFieldError"+                               , "NoSuchFieldException"+                               , "NoSuchMethodError"+                               , "NoSuchMethodException"+                               , "NoSuchObjectException"+                               , "NoSuchPaddingException"+                               , "NoSuchProviderException"+                               , "Node"+                               , "NodeChangeEvent"+                               , "NodeChangeListener"+                               , "NodeDimensions"+                               , "NodeList"+                               , "NonReadableChannelException"+                               , "NonWritableChannelException"+                               , "NoninvertibleTransformException"+                               , "NotActiveException"+                               , "NotBoundException"+                               , "NotContextException"+                               , "NotEmpty"+                               , "NotEmptyHelper"+                               , "NotEmptyHolder"+                               , "NotFound"+                               , "NotFoundHelper"+                               , "NotFoundHolder"+                               , "NotFoundReason"+                               , "NotFoundReasonHelper"+                               , "NotFoundReasonHolder"+                               , "NotOwnerException"+                               , "NotSerializableException"+                               , "NotYetBoundException"+                               , "NotYetConnectedException"+                               , "Notation"+                               , "NullCipher"+                               , "NullPointerException"+                               , "Number"+                               , "NumberEditor"+                               , "NumberFormat"+                               , "NumberFormatException"+                               , "NumberFormatter"+                               , "NumberOfDocuments"+                               , "NumberOfInterveningJobs"+                               , "NumberUp"+                               , "NumberUpSupported"+                               , "NumericShaper"+                               , "OBJECT_NOT_EXIST"+                               , "OBJ_ADAPTER"+                               , "OMGVMCID"+                               , "ORB"+                               , "ORBInitInfo"+                               , "ORBInitInfoOperations"+                               , "ORBInitializer"+                               , "ORBInitializerOperations"+                               , "ObjID"+                               , "Object"+                               , "ObjectAlreadyActive"+                               , "ObjectAlreadyActiveHelper"+                               , "ObjectChangeListener"+                               , "ObjectFactory"+                               , "ObjectFactoryBuilder"+                               , "ObjectHelper"+                               , "ObjectHolder"+                               , "ObjectIdHelper"+                               , "ObjectImpl"+                               , "ObjectInput"+                               , "ObjectInputStream"+                               , "ObjectInputValidation"+                               , "ObjectNotActive"+                               , "ObjectNotActiveHelper"+                               , "ObjectOutput"+                               , "ObjectOutputStream"+                               , "ObjectStreamClass"+                               , "ObjectStreamConstants"+                               , "ObjectStreamException"+                               , "ObjectStreamField"+                               , "ObjectView"+                               , "Observable"+                               , "Observer"+                               , "OctetSeqHelper"+                               , "OctetSeqHolder"+                               , "Oid"+                               , "OpenType"+                               , "Operation"+                               , "OperationNotSupportedException"+                               , "Option"+                               , "OptionDialogBorder"+                               , "OptionPaneUI"+                               , "OptionalDataException"+                               , "OrientationRequested"+                               , "OrientationRequestedType"+                               , "OriginType"+                               , "Other"+                               , "OutOfMemoryError"+                               , "OutputDeviceAssigned"+                               , "OutputKeys"+                               , "OutputStream"+                               , "OutputStreamWriter"+                               , "OverlappingFileLockException"+                               , "OverlayLayout"+                               , "Owner"+                               , "PBEKey"+                               , "PBEKeySpec"+                               , "PBEParameterSpec"+                               , "PDLOverrideSupported"+                               , "PERSIST_STORE"+                               , "PKCS8EncodedKeySpec"+                               , "PKIXBuilderParameters"+                               , "PKIXCertPathBuilderResult"+                               , "PKIXCertPathChecker"+                               , "PKIXCertPathValidatorResult"+                               , "PKIXParameters"+                               , "POA"+                               , "POAHelper"+                               , "POAManager"+                               , "POAManagerOperations"+                               , "POAOperations"+                               , "PRIVATE_MEMBER"+                               , "PSSParameterSpec"+                               , "PUBLIC_MEMBER"+                               , "Package"+                               , "PackedColorModel"+                               , "PageAttributes"+                               , "PageFormat"+                               , "PageRanges"+                               , "Pageable"+                               , "PagesPerMinute"+                               , "PagesPerMinuteColor"+                               , "Paint"+                               , "PaintContext"+                               , "PaintEvent"+                               , "PaletteBorder"+                               , "PaletteCloseIcon"+                               , "Panel"+                               , "PanelUI"+                               , "Paper"+                               , "ParagraphAttribute"+                               , "ParagraphConstants"+                               , "ParagraphView"+                               , "Parameter"+                               , "ParameterBlock"+                               , "ParameterDescriptor"+                               , "ParameterMetaData"+                               , "ParameterMode"+                               , "ParameterModeHelper"+                               , "ParameterModeHolder"+                               , "ParseException"+                               , "ParsePosition"+                               , "Parser"+                               , "ParserAdapter"+                               , "ParserCallback"+                               , "ParserConfigurationException"+                               , "ParserDelegator"+                               , "ParserFactory"+                               , "PartialResultException"+                               , "PasswordAuthentication"+                               , "PasswordCallback"+                               , "PasswordView"+                               , "PasteAction"+                               , "Patch"+                               , "PathIterator"+                               , "Pattern"+                               , "PatternSyntaxException"+                               , "Permission"+                               , "PermissionCollection"+                               , "Permissions"+                               , "PersistenceDelegate"+                               , "PhantomReference"+                               , "Pipe"+                               , "PipedInputStream"+                               , "PipedOutputStream"+                               , "PipedReader"+                               , "PipedWriter"+                               , "PixelGrabber"+                               , "PixelInterleavedSampleModel"+                               , "PlainDocument"+                               , "PlainView"+                               , "Point"+                               , "Point2D"+                               , "Policy"+                               , "PolicyError"+                               , "PolicyErrorCodeHelper"+                               , "PolicyErrorHelper"+                               , "PolicyErrorHolder"+                               , "PolicyFactory"+                               , "PolicyFactoryOperations"+                               , "PolicyHelper"+                               , "PolicyHolder"+                               , "PolicyListHelper"+                               , "PolicyListHolder"+                               , "PolicyNode"+                               , "PolicyOperations"+                               , "PolicyQualifierInfo"+                               , "PolicyTypeHelper"+                               , "Polygon"+                               , "PooledConnection"+                               , "Popup"+                               , "PopupFactory"+                               , "PopupMenu"+                               , "PopupMenuBorder"+                               , "PopupMenuEvent"+                               , "PopupMenuListener"+                               , "PopupMenuUI"+                               , "Port"+                               , "PortUnreachableException"+                               , "PortableRemoteObject"+                               , "PortableRemoteObjectDelegate"+                               , "Position"+                               , "PreferenceChangeEvent"+                               , "PreferenceChangeListener"+                               , "Preferences"+                               , "PreferencesFactory"+                               , "PreparedStatement"+                               , "PresentationDirection"+                               , "Principal"+                               , "PrincipalHolder"+                               , "PrintEvent"+                               , "PrintException"+                               , "PrintGraphics"+                               , "PrintJob"+                               , "PrintJobAdapter"+                               , "PrintJobAttribute"+                               , "PrintJobAttributeEvent"+                               , "PrintJobAttributeListener"+                               , "PrintJobAttributeSet"+                               , "PrintJobEvent"+                               , "PrintJobListener"+                               , "PrintQuality"+                               , "PrintQualityType"+                               , "PrintRequestAttribute"+                               , "PrintRequestAttributeSet"+                               , "PrintService"+                               , "PrintServiceAttribute"+                               , "PrintServiceAttributeEvent"+                               , "PrintServiceAttributeListener"+                               , "PrintServiceAttributeSet"+                               , "PrintServiceLookup"+                               , "PrintStream"+                               , "PrintWriter"+                               , "Printable"+                               , "PrinterAbortException"+                               , "PrinterException"+                               , "PrinterGraphics"+                               , "PrinterIOException"+                               , "PrinterInfo"+                               , "PrinterIsAcceptingJobs"+                               , "PrinterJob"+                               , "PrinterLocation"+                               , "PrinterMakeAndModel"+                               , "PrinterMessageFromOperator"+                               , "PrinterMoreInfo"+                               , "PrinterMoreInfoManufacturer"+                               , "PrinterName"+                               , "PrinterResolution"+                               , "PrinterState"+                               , "PrinterStateReason"+                               , "PrinterStateReasons"+                               , "PrinterURI"+                               , "PrivateCredentialPermission"+                               , "PrivateKey"+                               , "PrivilegedAction"+                               , "PrivilegedActionException"+                               , "PrivilegedExceptionAction"+                               , "Process"+                               , "ProcessingInstruction"+                               , "ProfileDataException"+                               , "ProfileIdHelper"+                               , "ProgressBarUI"+                               , "ProgressMonitor"+                               , "ProgressMonitorInputStream"+                               , "Properties"+                               , "PropertyChangeEvent"+                               , "PropertyChangeListener"+                               , "PropertyChangeListenerProxy"+                               , "PropertyChangeSupport"+                               , "PropertyDescriptor"+                               , "PropertyEditor"+                               , "PropertyEditorManager"+                               , "PropertyEditorSupport"+                               , "PropertyPermission"+                               , "PropertyResourceBundle"+                               , "PropertyVetoException"+                               , "ProtectionDomain"+                               , "ProtocolException"+                               , "Provider"+                               , "ProviderException"+                               , "Proxy"+                               , "ProxyLazyValue"+                               , "PublicKey"+                               , "PushbackInputStream"+                               , "PushbackReader"+                               , "PutField"+                               , "QuadCurve2D"+                               , "QueuedJobCount"+                               , "RC2ParameterSpec"+                               , "RC5ParameterSpec"+                               , "READER"+                               , "REQUEST_PROCESSING_POLICY_ID"+                               , "RGBImageFilter"+                               , "RMIClassLoader"+                               , "RMIClassLoaderSpi"+                               , "RMIClientSocketFactory"+                               , "RMIFailureHandler"+                               , "RMISecurityException"+                               , "RMISecurityManager"+                               , "RMIServerSocketFactory"+                               , "RMISocketFactory"+                               , "RSAKey"+                               , "RSAKeyGenParameterSpec"+                               , "RSAMultiPrimePrivateCrtKey"+                               , "RSAMultiPrimePrivateCrtKeySpec"+                               , "RSAOtherPrimeInfo"+                               , "RSAPrivateCrtKey"+                               , "RSAPrivateCrtKeySpec"+                               , "RSAPrivateKey"+                               , "RSAPrivateKeySpec"+                               , "RSAPublicKey"+                               , "RSAPublicKeySpec"+                               , "RTFEditorKit"+                               , "RadioButtonBorder"+                               , "Random"+                               , "RandomAccess"+                               , "RandomAccessFile"+                               , "Raster"+                               , "RasterFormatException"+                               , "RasterOp"+                               , "ReadOnlyBufferException"+                               , "ReadableByteChannel"+                               , "Reader"+                               , "Receiver"+                               , "Rectangle"+                               , "Rectangle2D"+                               , "RectangularShape"+                               , "Ref"+                               , "RefAddr"+                               , "Reference"+                               , "ReferenceQueue"+                               , "ReferenceUriSchemesSupported"+                               , "Referenceable"+                               , "ReferralException"+                               , "ReflectPermission"+                               , "RefreshFailedException"+                               , "Refreshable"+                               , "RegisterableService"+                               , "Registry"+                               , "RegistryHandler"+                               , "RemarshalException"+                               , "Remote"+                               , "RemoteCall"+                               , "RemoteException"+                               , "RemoteObject"+                               , "RemoteRef"+                               , "RemoteServer"+                               , "RemoteStub"+                               , "RenderContext"+                               , "RenderableImage"+                               , "RenderableImageOp"+                               , "RenderableImageProducer"+                               , "RenderedImage"+                               , "RenderedImageFactory"+                               , "Renderer"+                               , "RenderingHints"+                               , "RepaintManager"+                               , "ReplicateScaleFilter"+                               , "RepositoryIdHelper"+                               , "Request"+                               , "RequestInfo"+                               , "RequestInfoOperations"+                               , "RequestProcessingPolicy"+                               , "RequestProcessingPolicyOperations"+                               , "RequestProcessingPolicyValue"+                               , "RequestingUserName"+                               , "RescaleOp"+                               , "ResolutionSyntax"+                               , "ResolveResult"+                               , "Resolver"+                               , "ResourceBundle"+                               , "ResponseHandler"+                               , "Result"+                               , "ResultSet"+                               , "ResultSetMetaData"+                               , "ReverbType"+                               , "Robot"+                               , "RolloverButtonBorder"+                               , "RootPaneContainer"+                               , "RootPaneUI"+                               , "RoundRectangle2D"+                               , "RowMapper"+                               , "RowSet"+                               , "RowSetEvent"+                               , "RowSetInternal"+                               , "RowSetListener"+                               , "RowSetMetaData"+                               , "RowSetReader"+                               , "RowSetWriter"+                               , "RuleBasedCollator"+                               , "RunTime"+                               , "RunTimeOperations"+                               , "Runnable"+                               , "Runtime"+                               , "RuntimeException"+                               , "RuntimePermission"+                               , "SAXException"+                               , "SAXNotRecognizedException"+                               , "SAXNotSupportedException"+                               , "SAXParseException"+                               , "SAXParser"+                               , "SAXParserFactory"+                               , "SAXResult"+                               , "SAXSource"+                               , "SAXTransformerFactory"+                               , "SERVANT_RETENTION_POLICY_ID"+                               , "SERVICE_FORMATTED"+                               , "SQLData"+                               , "SQLException"+                               , "SQLInput"+                               , "SQLOutput"+                               , "SQLPermission"+                               , "SQLWarning"+                               , "SSLContext"+                               , "SSLContextSpi"+                               , "SSLException"+                               , "SSLHandshakeException"+                               , "SSLKeyException"+                               , "SSLPeerUnverifiedException"+                               , "SSLPermission"+                               , "SSLProtocolException"+                               , "SSLServerSocket"+                               , "SSLServerSocketFactory"+                               , "SSLSession"+                               , "SSLSessionBindingEvent"+                               , "SSLSessionBindingListener"+                               , "SSLSessionContext"+                               , "SSLSocket"+                               , "SSLSocketFactory"+                               , "STRING"+                               , "SUCCESSFUL"+                               , "SYNC_WITH_TRANSPORT"+                               , "SYSTEM_EXCEPTION"+                               , "SampleModel"+                               , "Savepoint"+                               , "ScatteringByteChannel"+                               , "SchemaViolationException"+                               , "ScrollBarUI"+                               , "ScrollPane"+                               , "ScrollPaneAdjustable"+                               , "ScrollPaneBorder"+                               , "ScrollPaneConstants"+                               , "ScrollPaneLayout"+                               , "ScrollPaneUI"+                               , "Scrollable"+                               , "Scrollbar"+                               , "SealedObject"+                               , "SearchControls"+                               , "SearchResult"+                               , "SecretKey"+                               , "SecretKeyFactory"+                               , "SecretKeyFactorySpi"+                               , "SecretKeySpec"+                               , "SecureClassLoader"+                               , "SecureRandom"+                               , "SecureRandomSpi"+                               , "Security"+                               , "SecurityException"+                               , "SecurityManager"+                               , "SecurityPermission"+                               , "Segment"+                               , "SelectableChannel"+                               , "SelectionKey"+                               , "Selector"+                               , "SelectorProvider"+                               , "Separator"+                               , "SeparatorUI"+                               , "Sequence"+                               , "SequenceInputStream"+                               , "Sequencer"+                               , "Serializable"+                               , "SerializablePermission"+                               , "Servant"+                               , "ServantActivator"+                               , "ServantActivatorHelper"+                               , "ServantActivatorOperations"+                               , "ServantActivatorPOA"+                               , "ServantAlreadyActive"+                               , "ServantAlreadyActiveHelper"+                               , "ServantLocator"+                               , "ServantLocatorHelper"+                               , "ServantLocatorOperations"+                               , "ServantLocatorPOA"+                               , "ServantManager"+                               , "ServantManagerOperations"+                               , "ServantNotActive"+                               , "ServantNotActiveHelper"+                               , "ServantObject"+                               , "ServantRetentionPolicy"+                               , "ServantRetentionPolicyOperations"+                               , "ServantRetentionPolicyValue"+                               , "ServerCloneException"+                               , "ServerError"+                               , "ServerException"+                               , "ServerNotActiveException"+                               , "ServerRef"+                               , "ServerRequest"+                               , "ServerRequestInfo"+                               , "ServerRequestInfoOperations"+                               , "ServerRequestInterceptor"+                               , "ServerRequestInterceptorOperations"+                               , "ServerRuntimeException"+                               , "ServerSocket"+                               , "ServerSocketChannel"+                               , "ServerSocketFactory"+                               , "ServiceContext"+                               , "ServiceContextHelper"+                               , "ServiceContextHolder"+                               , "ServiceContextListHelper"+                               , "ServiceContextListHolder"+                               , "ServiceDetail"+                               , "ServiceDetailHelper"+                               , "ServiceIdHelper"+                               , "ServiceInformation"+                               , "ServiceInformationHelper"+                               , "ServiceInformationHolder"+                               , "ServicePermission"+                               , "ServiceRegistry"+                               , "ServiceUI"+                               , "ServiceUIFactory"+                               , "ServiceUnavailableException"+                               , "Set"+                               , "SetOfIntegerSyntax"+                               , "SetOverrideType"+                               , "SetOverrideTypeHelper"+                               , "Severity"+                               , "Shape"+                               , "ShapeGraphicAttribute"+                               , "SheetCollate"+                               , "Short"+                               , "ShortBuffer"+                               , "ShortBufferException"+                               , "ShortHolder"+                               , "ShortLookupTable"+                               , "ShortMessage"+                               , "ShortSeqHelper"+                               , "ShortSeqHolder"+                               , "Sides"+                               , "SidesType"+                               , "Signature"+                               , "SignatureException"+                               , "SignatureSpi"+                               , "SignedObject"+                               , "Signer"+                               , "SimpleAttributeSet"+                               , "SimpleBeanInfo"+                               , "SimpleDateFormat"+                               , "SimpleDoc"+                               , "SimpleFormatter"+                               , "SimpleTimeZone"+                               , "SinglePixelPackedSampleModel"+                               , "SingleSelectionModel"+                               , "SinkChannel"+                               , "Size2DSyntax"+                               , "SizeLimitExceededException"+                               , "SizeRequirements"+                               , "SizeSequence"+                               , "Skeleton"+                               , "SkeletonMismatchException"+                               , "SkeletonNotFoundException"+                               , "SliderUI"+                               , "Socket"+                               , "SocketAddress"+                               , "SocketChannel"+                               , "SocketException"+                               , "SocketFactory"+                               , "SocketHandler"+                               , "SocketImpl"+                               , "SocketImplFactory"+                               , "SocketOptions"+                               , "SocketPermission"+                               , "SocketSecurityException"+                               , "SocketTimeoutException"+                               , "SoftBevelBorder"+                               , "SoftReference"+                               , "SortedMap"+                               , "SortedSet"+                               , "SortingFocusTraversalPolicy"+                               , "Soundbank"+                               , "SoundbankReader"+                               , "SoundbankResource"+                               , "Source"+                               , "SourceChannel"+                               , "SourceDataLine"+                               , "SourceLocator"+                               , "SpinnerDateModel"+                               , "SpinnerListModel"+                               , "SpinnerModel"+                               , "SpinnerNumberModel"+                               , "SpinnerUI"+                               , "SplitPaneBorder"+                               , "SplitPaneUI"+                               , "Spring"+                               , "SpringLayout"+                               , "Stack"+                               , "StackOverflowError"+                               , "StackTraceElement"+                               , "StartTlsRequest"+                               , "StartTlsResponse"+                               , "State"+                               , "StateEdit"+                               , "StateEditable"+                               , "StateFactory"+                               , "Statement"+                               , "StreamCorruptedException"+                               , "StreamHandler"+                               , "StreamPrintService"+                               , "StreamPrintServiceFactory"+                               , "StreamResult"+                               , "StreamSource"+                               , "StreamTokenizer"+                               , "Streamable"+                               , "StreamableValue"+                               , "StrictMath"+                               , "String"+                               , "StringBuffer"+                               , "StringBufferInputStream"+                               , "StringCharacterIterator"+                               , "StringContent"+                               , "StringHolder"+                               , "StringIndexOutOfBoundsException"+                               , "StringNameHelper"+                               , "StringReader"+                               , "StringRefAddr"+                               , "StringSelection"+                               , "StringSeqHelper"+                               , "StringSeqHolder"+                               , "StringTokenizer"+                               , "StringValueHelper"+                               , "StringWriter"+                               , "Stroke"+                               , "Struct"+                               , "StructMember"+                               , "StructMemberHelper"+                               , "Stub"+                               , "StubDelegate"+                               , "StubNotFoundException"+                               , "Style"+                               , "StyleConstants"+                               , "StyleContext"+                               , "StyleSheet"+                               , "StyledDocument"+                               , "StyledEditorKit"+                               , "StyledTextAction"+                               , "Subject"+                               , "SubjectDomainCombiner"+                               , "Subset"+                               , "SupportedValuesAttribute"+                               , "SwingConstants"+                               , "SwingPropertyChangeSupport"+                               , "SwingUtilities"+                               , "SyncFailedException"+                               , "SyncMode"+                               , "SyncScopeHelper"+                               , "Synthesizer"+                               , "SysexMessage"+                               , "System"+                               , "SystemColor"+                               , "SystemException"+                               , "SystemFlavorMap"+                               , "TAG_ALTERNATE_IIOP_ADDRESS"+                               , "TAG_CODE_SETS"+                               , "TAG_INTERNET_IOP"+                               , "TAG_JAVA_CODEBASE"+                               , "TAG_MULTIPLE_COMPONENTS"+                               , "TAG_ORB_TYPE"+                               , "TAG_POLICIES"+                               , "TCKind"+                               , "THREAD_POLICY_ID"+                               , "TRANSACTION_REQUIRED"+                               , "TRANSACTION_ROLLEDBACK"+                               , "TRANSIENT"+                               , "TRANSPORT_RETRY"+                               , "TabExpander"+                               , "TabSet"+                               , "TabStop"+                               , "TabableView"+                               , "TabbedPaneUI"+                               , "TableCellEditor"+                               , "TableCellRenderer"+                               , "TableColumn"+                               , "TableColumnModel"+                               , "TableColumnModelEvent"+                               , "TableColumnModelListener"+                               , "TableHeaderBorder"+                               , "TableHeaderUI"+                               , "TableModel"+                               , "TableModelEvent"+                               , "TableModelListener"+                               , "TableUI"+                               , "TableView"+                               , "Tag"+                               , "TagElement"+                               , "TaggedComponent"+                               , "TaggedComponentHelper"+                               , "TaggedComponentHolder"+                               , "TaggedProfile"+                               , "TaggedProfileHelper"+                               , "TaggedProfileHolder"+                               , "TargetDataLine"+                               , "Templates"+                               , "TemplatesHandler"+                               , "Text"+                               , "TextAction"+                               , "TextArea"+                               , "TextAttribute"+                               , "TextComponent"+                               , "TextEvent"+                               , "TextField"+                               , "TextFieldBorder"+                               , "TextHitInfo"+                               , "TextInputCallback"+                               , "TextLayout"+                               , "TextListener"+                               , "TextMeasurer"+                               , "TextOutputCallback"+                               , "TextSyntax"+                               , "TextUI"+                               , "TexturePaint"+                               , "Thread"+                               , "ThreadDeath"+                               , "ThreadGroup"+                               , "ThreadLocal"+                               , "ThreadPolicy"+                               , "ThreadPolicyOperations"+                               , "ThreadPolicyValue"+                               , "Throwable"+                               , "Tie"+                               , "TileObserver"+                               , "Time"+                               , "TimeLimitExceededException"+                               , "TimeZone"+                               , "Timer"+                               , "TimerTask"+                               , "Timestamp"+                               , "TitledBorder"+                               , "TitledBorderUIResource"+                               , "ToggleButtonBorder"+                               , "ToggleButtonModel"+                               , "TooManyListenersException"+                               , "ToolBarBorder"+                               , "ToolBarUI"+                               , "ToolTipManager"+                               , "ToolTipUI"+                               , "Toolkit"+                               , "Track"+                               , "TransactionRequiredException"+                               , "TransactionRolledbackException"+                               , "TransactionService"+                               , "TransferHandler"+                               , "Transferable"+                               , "TransformAttribute"+                               , "Transformer"+                               , "TransformerConfigurationException"+                               , "TransformerException"+                               , "TransformerFactory"+                               , "TransformerFactoryConfigurationError"+                               , "TransformerHandler"+                               , "Transmitter"+                               , "Transparency"+                               , "TreeCellEditor"+                               , "TreeCellRenderer"+                               , "TreeControlIcon"+                               , "TreeExpansionEvent"+                               , "TreeExpansionListener"+                               , "TreeFolderIcon"+                               , "TreeLeafIcon"+                               , "TreeMap"+                               , "TreeModel"+                               , "TreeModelEvent"+                               , "TreeModelListener"+                               , "TreeNode"+                               , "TreePath"+                               , "TreeSelectionEvent"+                               , "TreeSelectionListener"+                               , "TreeSelectionModel"+                               , "TreeSet"+                               , "TreeUI"+                               , "TreeWillExpandListener"+                               , "TrustAnchor"+                               , "TrustManager"+                               , "TrustManagerFactory"+                               , "TrustManagerFactorySpi"+                               , "Type"+                               , "TypeCode"+                               , "TypeCodeHolder"+                               , "TypeMismatch"+                               , "TypeMismatchHelper"+                               , "Types"+                               , "UID"+                               , "UIDefaults"+                               , "UIManager"+                               , "UIResource"+                               , "ULongLongSeqHelper"+                               , "ULongLongSeqHolder"+                               , "ULongSeqHelper"+                               , "ULongSeqHolder"+                               , "UNKNOWN"+                               , "UNSUPPORTED_POLICY"+                               , "UNSUPPORTED_POLICY_VALUE"+                               , "URI"+                               , "URIException"+                               , "URIResolver"+                               , "URISyntax"+                               , "URISyntaxException"+                               , "URL"+                               , "URLClassLoader"+                               , "URLConnection"+                               , "URLDecoder"+                               , "URLEncoder"+                               , "URLStreamHandler"+                               , "URLStreamHandlerFactory"+                               , "URLStringHelper"+                               , "USER_EXCEPTION"+                               , "UShortSeqHelper"+                               , "UShortSeqHolder"+                               , "UTFDataFormatException"+                               , "UndeclaredThrowableException"+                               , "UnderlineAction"+                               , "UndoManager"+                               , "UndoableEdit"+                               , "UndoableEditEvent"+                               , "UndoableEditListener"+                               , "UndoableEditSupport"+                               , "UnexpectedException"+                               , "UnicastRemoteObject"+                               , "UnicodeBlock"+                               , "UnionMember"+                               , "UnionMemberHelper"+                               , "UnknownEncoding"+                               , "UnknownEncodingHelper"+                               , "UnknownError"+                               , "UnknownException"+                               , "UnknownGroupException"+                               , "UnknownHostException"+                               , "UnknownObjectException"+                               , "UnknownServiceException"+                               , "UnknownTag"+                               , "UnknownUserException"+                               , "UnknownUserExceptionHelper"+                               , "UnknownUserExceptionHolder"+                               , "UnmappableCharacterException"+                               , "UnmarshalException"+                               , "UnmodifiableSetException"+                               , "UnrecoverableKeyException"+                               , "Unreferenced"+                               , "UnresolvedAddressException"+                               , "UnresolvedPermission"+                               , "UnsatisfiedLinkError"+                               , "UnsolicitedNotification"+                               , "UnsolicitedNotificationEvent"+                               , "UnsolicitedNotificationListener"+                               , "UnsupportedAddressTypeException"+                               , "UnsupportedAudioFileException"+                               , "UnsupportedCallbackException"+                               , "UnsupportedCharsetException"+                               , "UnsupportedClassVersionError"+                               , "UnsupportedEncodingException"+                               , "UnsupportedFlavorException"+                               , "UnsupportedLookAndFeelException"+                               , "UnsupportedOperationException"+                               , "UserException"+                               , "Util"+                               , "UtilDelegate"+                               , "Utilities"+                               , "VMID"+                               , "VM_ABSTRACT"+                               , "VM_CUSTOM"+                               , "VM_NONE"+                               , "VM_TRUNCATABLE"+                               , "ValueBase"+                               , "ValueBaseHelper"+                               , "ValueBaseHolder"+                               , "ValueFactory"+                               , "ValueHandler"+                               , "ValueMember"+                               , "ValueMemberHelper"+                               , "VariableHeightLayoutCache"+                               , "Vector"+                               , "VerifyError"+                               , "VersionSpecHelper"+                               , "VetoableChangeListener"+                               , "VetoableChangeListenerProxy"+                               , "VetoableChangeSupport"+                               , "View"+                               , "ViewFactory"+                               , "ViewportLayout"+                               , "ViewportUI"+                               , "VirtualMachineError"+                               , "Visibility"+                               , "VisibilityHelper"+                               , "VoiceStatus"+                               , "Void"+                               , "VolatileImage"+                               , "WCharSeqHelper"+                               , "WCharSeqHolder"+                               , "WStringSeqHelper"+                               , "WStringSeqHolder"+                               , "WStringValueHelper"+                               , "WeakHashMap"+                               , "WeakReference"+                               , "Window"+                               , "WindowAdapter"+                               , "WindowConstants"+                               , "WindowEvent"+                               , "WindowFocusListener"+                               , "WindowListener"+                               , "WindowStateListener"+                               , "WrappedPlainView"+                               , "WritableByteChannel"+                               , "WritableRaster"+                               , "WritableRenderedImage"+                               , "WriteAbortedException"+                               , "Writer"+                               , "WrongAdapter"+                               , "WrongAdapterHelper"+                               , "WrongPolicy"+                               , "WrongPolicyHelper"+                               , "WrongTransaction"+                               , "WrongTransactionHelper"+                               , "WrongTransactionHolder"+                               , "X500Principal"+                               , "X500PrivateCredential"+                               , "X509CRL"+                               , "X509CRLEntry"+                               , "X509CRLSelector"+                               , "X509CertSelector"+                               , "X509Certificate"+                               , "X509EncodedKeySpec"+                               , "X509Extension"+                               , "X509KeyManager"+                               , "X509TrustManager"+                               , "XAConnection"+                               , "XADataSource"+                               , "XAException"+                               , "XAResource"+                               , "XMLDecoder"+                               , "XMLEncoder"+                               , "XMLFilter"+                               , "XMLFilterImpl"+                               , "XMLFormatter"+                               , "XMLReader"+                               , "XMLReaderAdapter"+                               , "XMLReaderFactory"+                               , "Xid"+                               , "ZipEntry"+                               , "ZipException"+                               , "ZipFile"+                               , "ZipInputStream"+                               , "ZipOutputStream"+                               , "ZoneView"+                               , "_BindingIteratorImplBase"+                               , "_BindingIteratorStub"+                               , "_DynAnyFactoryStub"+                               , "_DynAnyStub"+                               , "_DynArrayStub"+                               , "_DynEnumStub"+                               , "_DynFixedStub"+                               , "_DynSequenceStub"+                               , "_DynStructStub"+                               , "_DynUnionStub"+                               , "_DynValueStub"+                               , "_IDLTypeStub"+                               , "_NamingContextExtStub"+                               , "_NamingContextImplBase"+                               , "_NamingContextStub"+                               , "_PolicyStub"+                               , "_Remote_Stub"+                               , "_ServantActivatorStub"+                               , "_ServantLocatorStub"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren =+                          [ Rule+                              { rMatcher = AnyChar "fF"+                              , rAttribute = FloatTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren =+                          [ Rule+                              { rMatcher = StringDetect "ULL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LUL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LLU"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "UL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LU"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "U"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "L"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Java String" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "!%&()+,-<=>?[]^{|}~"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Jsp Scriptlet"+          , Context+              { cName = "Jsp Scriptlet"+              , cSyntax = "JSP"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '%' '>'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\s*jsp:(declaration|expression|scriptlet)\\s*>"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False "<\\s*jsp:(declaration|expression|scriptlet)\\s*>")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Scriptlet" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "abstract"+                               , "assert"+                               , "break"+                               , "case"+                               , "catch"+                               , "class"+                               , "continue"+                               , "default"+                               , "do"+                               , "else"+                               , "extends"+                               , "false"+                               , "finally"+                               , "for"+                               , "goto"+                               , "if"+                               , "implements"+                               , "import"+                               , "instanceof"+                               , "interface"+                               , "native"+                               , "new"+                               , "null"+                               , "package"+                               , "private"+                               , "protected"+                               , "public"+                               , "return"+                               , "strictfp"+                               , "super"+                               , "switch"+                               , "synchronized"+                               , "this"+                               , "throw"+                               , "throws"+                               , "transient"+                               , "true"+                               , "try"+                               , "volatile"+                               , "while"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "and"+                               , "div"+                               , "empty"+                               , "eq"+                               , "false"+                               , "ge"+                               , "gt"+                               , "instanceof"+                               , "le"+                               , "lt"+                               , "mod"+                               , "ne"+                               , "not"+                               , "null"+                               , "or"+                               , "true"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "boolean"+                               , "byte"+                               , "char"+                               , "const"+                               , "double"+                               , "final"+                               , "float"+                               , "int"+                               , "long"+                               , "short"+                               , "static"+                               , "void"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ARG_IN"+                               , "ARG_INOUT"+                               , "ARG_OUT"+                               , "AWTError"+                               , "AWTEvent"+                               , "AWTEventListener"+                               , "AWTEventListenerProxy"+                               , "AWTEventMulticaster"+                               , "AWTException"+                               , "AWTKeyStroke"+                               , "AWTPermission"+                               , "AbstractAction"+                               , "AbstractBorder"+                               , "AbstractButton"+                               , "AbstractCellEditor"+                               , "AbstractCollection"+                               , "AbstractColorChooserPanel"+                               , "AbstractDocument"+                               , "AbstractFormatter"+                               , "AbstractFormatterFactory"+                               , "AbstractInterruptibleChannel"+                               , "AbstractLayoutCache"+                               , "AbstractList"+                               , "AbstractListModel"+                               , "AbstractMap"+                               , "AbstractMethodError"+                               , "AbstractPreferences"+                               , "AbstractSelectableChannel"+                               , "AbstractSelectionKey"+                               , "AbstractSelector"+                               , "AbstractSequentialList"+                               , "AbstractSet"+                               , "AbstractSpinnerModel"+                               , "AbstractTableModel"+                               , "AbstractUndoableEdit"+                               , "AbstractWriter"+                               , "AccessControlContext"+                               , "AccessControlException"+                               , "AccessController"+                               , "AccessException"+                               , "Accessible"+                               , "AccessibleAction"+                               , "AccessibleBundle"+                               , "AccessibleComponent"+                               , "AccessibleContext"+                               , "AccessibleEditableText"+                               , "AccessibleExtendedComponent"+                               , "AccessibleExtendedTable"+                               , "AccessibleHyperlink"+                               , "AccessibleHypertext"+                               , "AccessibleIcon"+                               , "AccessibleKeyBinding"+                               , "AccessibleObject"+                               , "AccessibleRelation"+                               , "AccessibleRelationSet"+                               , "AccessibleResourceBundle"+                               , "AccessibleRole"+                               , "AccessibleSelection"+                               , "AccessibleState"+                               , "AccessibleStateSet"+                               , "AccessibleTable"+                               , "AccessibleTableModelChange"+                               , "AccessibleText"+                               , "AccessibleValue"+                               , "AccountExpiredException"+                               , "Acl"+                               , "AclEntry"+                               , "AclNotFoundException"+                               , "Action"+                               , "ActionEvent"+                               , "ActionListener"+                               , "ActionMap"+                               , "ActionMapUIResource"+                               , "Activatable"+                               , "ActivateFailedException"+                               , "ActivationDesc"+                               , "ActivationException"+                               , "ActivationGroup"+                               , "ActivationGroupDesc"+                               , "ActivationGroupID"+                               , "ActivationGroup_Stub"+                               , "ActivationID"+                               , "ActivationInstantiator"+                               , "ActivationMonitor"+                               , "ActivationSystem"+                               , "Activator"+                               , "ActiveEvent"+                               , "ActiveValue"+                               , "AdapterActivator"+                               , "AdapterActivatorOperations"+                               , "AdapterAlreadyExists"+                               , "AdapterAlreadyExistsHelper"+                               , "AdapterInactive"+                               , "AdapterInactiveHelper"+                               , "AdapterNonExistent"+                               , "AdapterNonExistentHelper"+                               , "AddressHelper"+                               , "Adjustable"+                               , "AdjustmentEvent"+                               , "AdjustmentListener"+                               , "Adler32"+                               , "AffineTransform"+                               , "AffineTransformOp"+                               , "AlgorithmParameterGenerator"+                               , "AlgorithmParameterGeneratorSpi"+                               , "AlgorithmParameterSpec"+                               , "AlgorithmParameters"+                               , "AlgorithmParametersSpi"+                               , "AlignmentAction"+                               , "AllPermission"+                               , "AlphaComposite"+                               , "AlreadyBound"+                               , "AlreadyBoundException"+                               , "AlreadyBoundHelper"+                               , "AlreadyBoundHolder"+                               , "AlreadyConnectedException"+                               , "AncestorEvent"+                               , "AncestorListener"+                               , "Annotation"+                               , "Any"+                               , "AnyHolder"+                               , "AnySeqHelper"+                               , "AnySeqHolder"+                               , "AppConfigurationEntry"+                               , "Applet"+                               , "AppletContext"+                               , "AppletInitializer"+                               , "AppletStub"+                               , "ApplicationException"+                               , "Arc2D"+                               , "Area"+                               , "AreaAveragingScaleFilter"+                               , "ArithmeticException"+                               , "Array"+                               , "ArrayIndexOutOfBoundsException"+                               , "ArrayList"+                               , "ArrayStoreException"+                               , "Arrays"+                               , "AssertionError"+                               , "AsyncBoxView"+                               , "AsynchronousCloseException"+                               , "Attr"+                               , "Attribute"+                               , "AttributeContext"+                               , "AttributeException"+                               , "AttributeInUseException"+                               , "AttributeList"+                               , "AttributeListImpl"+                               , "AttributeModificationException"+                               , "AttributeSet"+                               , "AttributeSetUtilities"+                               , "AttributeUndoableEdit"+                               , "AttributedCharacterIterator"+                               , "AttributedString"+                               , "Attributes"+                               , "AttributesImpl"+                               , "AudioClip"+                               , "AudioFileFormat"+                               , "AudioFileReader"+                               , "AudioFileWriter"+                               , "AudioFormat"+                               , "AudioInputStream"+                               , "AudioPermission"+                               , "AudioSystem"+                               , "AuthPermission"+                               , "AuthenticationException"+                               , "AuthenticationNotSupportedException"+                               , "Authenticator"+                               , "Autoscroll"+                               , "BAD_CONTEXT"+                               , "BAD_INV_ORDER"+                               , "BAD_OPERATION"+                               , "BAD_PARAM"+                               , "BAD_POLICY"+                               , "BAD_POLICY_TYPE"+                               , "BAD_POLICY_VALUE"+                               , "BAD_TYPECODE"+                               , "BCSIterator"+                               , "BCSSServiceProvider"+                               , "BYTE_ARRAY"+                               , "BackingStoreException"+                               , "BadKind"+                               , "BadLocationException"+                               , "BadPaddingException"+                               , "BandCombineOp"+                               , "BandedSampleModel"+                               , "BasicArrowButton"+                               , "BasicAttribute"+                               , "BasicAttributes"+                               , "BasicBorders"+                               , "BasicButtonListener"+                               , "BasicButtonUI"+                               , "BasicCaret"+                               , "BasicCheckBoxMenuItemUI"+                               , "BasicCheckBoxUI"+                               , "BasicColorChooserUI"+                               , "BasicComboBoxEditor"+                               , "BasicComboBoxRenderer"+                               , "BasicComboBoxUI"+                               , "BasicComboPopup"+                               , "BasicDesktopIconUI"+                               , "BasicDesktopPaneUI"+                               , "BasicDirectoryModel"+                               , "BasicEditorPaneUI"+                               , "BasicFileChooserUI"+                               , "BasicFormattedTextFieldUI"+                               , "BasicGraphicsUtils"+                               , "BasicHTML"+                               , "BasicHighlighter"+                               , "BasicIconFactory"+                               , "BasicInternalFrameTitlePane"+                               , "BasicInternalFrameUI"+                               , "BasicLabelUI"+                               , "BasicListUI"+                               , "BasicLookAndFeel"+                               , "BasicMenuBarUI"+                               , "BasicMenuItemUI"+                               , "BasicMenuUI"+                               , "BasicOptionPaneUI"+                               , "BasicPanelUI"+                               , "BasicPasswordFieldUI"+                               , "BasicPermission"+                               , "BasicPopupMenuSeparatorUI"+                               , "BasicPopupMenuUI"+                               , "BasicProgressBarUI"+                               , "BasicRadioButtonMenuItemUI"+                               , "BasicRadioButtonUI"+                               , "BasicRootPaneUI"+                               , "BasicScrollBarUI"+                               , "BasicScrollPaneUI"+                               , "BasicSeparatorUI"+                               , "BasicSliderUI"+                               , "BasicSpinnerUI"+                               , "BasicSplitPaneDivider"+                               , "BasicSplitPaneUI"+                               , "BasicStroke"+                               , "BasicTabbedPaneUI"+                               , "BasicTableHeaderUI"+                               , "BasicTableUI"+                               , "BasicTextAreaUI"+                               , "BasicTextFieldUI"+                               , "BasicTextPaneUI"+                               , "BasicTextUI"+                               , "BasicToggleButtonUI"+                               , "BasicToolBarSeparatorUI"+                               , "BasicToolBarUI"+                               , "BasicToolTipUI"+                               , "BasicTreeUI"+                               , "BasicViewportUI"+                               , "BatchUpdateException"+                               , "BeanContext"+                               , "BeanContextChild"+                               , "BeanContextChildComponentProxy"+                               , "BeanContextChildSupport"+                               , "BeanContextContainerProxy"+                               , "BeanContextEvent"+                               , "BeanContextMembershipEvent"+                               , "BeanContextMembershipListener"+                               , "BeanContextProxy"+                               , "BeanContextServiceAvailableEvent"+                               , "BeanContextServiceProvider"+                               , "BeanContextServiceProviderBeanInfo"+                               , "BeanContextServiceRevokedEvent"+                               , "BeanContextServiceRevokedListener"+                               , "BeanContextServices"+                               , "BeanContextServicesListener"+                               , "BeanContextServicesSupport"+                               , "BeanContextSupport"+                               , "BeanDescriptor"+                               , "BeanInfo"+                               , "Beans"+                               , "BeepAction"+                               , "BevelBorder"+                               , "BevelBorderUIResource"+                               , "Bias"+                               , "Bidi"+                               , "BigDecimal"+                               , "BigInteger"+                               , "BinaryRefAddr"+                               , "BindException"+                               , "Binding"+                               , "BindingHelper"+                               , "BindingHolder"+                               , "BindingIterator"+                               , "BindingIteratorHelper"+                               , "BindingIteratorHolder"+                               , "BindingIteratorOperations"+                               , "BindingIteratorPOA"+                               , "BindingListHelper"+                               , "BindingListHolder"+                               , "BindingType"+                               , "BindingTypeHelper"+                               , "BindingTypeHolder"+                               , "BitSet"+                               , "Blob"+                               , "BlockView"+                               , "BoldAction"+                               , "Book"+                               , "Boolean"+                               , "BooleanControl"+                               , "BooleanHolder"+                               , "BooleanSeqHelper"+                               , "BooleanSeqHolder"+                               , "Border"+                               , "BorderFactory"+                               , "BorderLayout"+                               , "BorderUIResource"+                               , "BoundedRangeModel"+                               , "Bounds"+                               , "Box"+                               , "BoxLayout"+                               , "BoxPainter"+                               , "BoxView"+                               , "BoxedValueHelper"+                               , "BreakIterator"+                               , "Buffer"+                               , "BufferCapabilities"+                               , "BufferOverflowException"+                               , "BufferStrategy"+                               , "BufferUnderflowException"+                               , "BufferedImage"+                               , "BufferedImageFilter"+                               , "BufferedImageOp"+                               , "BufferedInputStream"+                               , "BufferedOutputStream"+                               , "BufferedReader"+                               , "BufferedWriter"+                               , "Button"+                               , "ButtonAreaLayout"+                               , "ButtonBorder"+                               , "ButtonGroup"+                               , "ButtonModel"+                               , "ButtonUI"+                               , "Byte"+                               , "ByteArrayInputStream"+                               , "ByteArrayOutputStream"+                               , "ByteBuffer"+                               , "ByteChannel"+                               , "ByteHolder"+                               , "ByteLookupTable"+                               , "ByteOrder"+                               , "CDATASection"+                               , "CHAR_ARRAY"+                               , "CMMException"+                               , "COMM_FAILURE"+                               , "CRC32"+                               , "CRL"+                               , "CRLException"+                               , "CRLSelector"+                               , "CSS"+                               , "CTX_RESTRICT_SCOPE"+                               , "Calendar"+                               , "CallableStatement"+                               , "Callback"+                               , "CallbackHandler"+                               , "CancelablePrintJob"+                               , "CancelledKeyException"+                               , "CannotProceed"+                               , "CannotProceedException"+                               , "CannotProceedHelper"+                               , "CannotProceedHolder"+                               , "CannotRedoException"+                               , "CannotUndoException"+                               , "Canvas"+                               , "CardLayout"+                               , "Caret"+                               , "CaretEvent"+                               , "CaretListener"+                               , "CaretPolicy"+                               , "CellEditor"+                               , "CellEditorListener"+                               , "CellRendererPane"+                               , "CertPath"+                               , "CertPathBuilder"+                               , "CertPathBuilderException"+                               , "CertPathBuilderResult"+                               , "CertPathBuilderSpi"+                               , "CertPathParameters"+                               , "CertPathRep"+                               , "CertPathValidator"+                               , "CertPathValidatorException"+                               , "CertPathValidatorResult"+                               , "CertPathValidatorSpi"+                               , "CertSelector"+                               , "CertStore"+                               , "CertStoreException"+                               , "CertStoreParameters"+                               , "CertStoreSpi"+                               , "Certificate"+                               , "CertificateEncodingException"+                               , "CertificateException"+                               , "CertificateExpiredException"+                               , "CertificateFactory"+                               , "CertificateFactorySpi"+                               , "CertificateNotYetValidException"+                               , "CertificateParsingException"+                               , "CertificateRep"+                               , "ChangeEvent"+                               , "ChangeListener"+                               , "ChangedCharSetException"+                               , "Channel"+                               , "ChannelBinding"+                               , "Channels"+                               , "CharArrayReader"+                               , "CharArrayWriter"+                               , "CharBuffer"+                               , "CharConversionException"+                               , "CharHolder"+                               , "CharSeqHelper"+                               , "CharSeqHolder"+                               , "CharSequence"+                               , "Character"+                               , "CharacterAttribute"+                               , "CharacterCodingException"+                               , "CharacterConstants"+                               , "CharacterData"+                               , "CharacterIterator"+                               , "Charset"+                               , "CharsetDecoder"+                               , "CharsetEncoder"+                               , "CharsetProvider"+                               , "Checkbox"+                               , "CheckboxGroup"+                               , "CheckboxMenuItem"+                               , "CheckedInputStream"+                               , "CheckedOutputStream"+                               , "Checksum"+                               , "Choice"+                               , "ChoiceCallback"+                               , "ChoiceFormat"+                               , "Chromaticity"+                               , "Cipher"+                               , "CipherInputStream"+                               , "CipherOutputStream"+                               , "CipherSpi"+                               , "Class"+                               , "ClassCastException"+                               , "ClassCircularityError"+                               , "ClassDesc"+                               , "ClassFormatError"+                               , "ClassLoader"+                               , "ClassNotFoundException"+                               , "ClientRequestInfo"+                               , "ClientRequestInfoOperations"+                               , "ClientRequestInterceptor"+                               , "ClientRequestInterceptorOperations"+                               , "Clip"+                               , "Clipboard"+                               , "ClipboardOwner"+                               , "Clob"+                               , "CloneNotSupportedException"+                               , "Cloneable"+                               , "ClosedByInterruptException"+                               , "ClosedChannelException"+                               , "ClosedSelectorException"+                               , "CodeSets"+                               , "CodeSource"+                               , "Codec"+                               , "CodecFactory"+                               , "CodecFactoryHelper"+                               , "CodecFactoryOperations"+                               , "CodecOperations"+                               , "CoderMalfunctionError"+                               , "CoderResult"+                               , "CodingErrorAction"+                               , "CollationElementIterator"+                               , "CollationKey"+                               , "Collator"+                               , "Collection"+                               , "CollectionCertStoreParameters"+                               , "Collections"+                               , "Color"+                               , "ColorAttribute"+                               , "ColorChooserComponentFactory"+                               , "ColorChooserUI"+                               , "ColorConstants"+                               , "ColorConvertOp"+                               , "ColorModel"+                               , "ColorSelectionModel"+                               , "ColorSpace"+                               , "ColorSupported"+                               , "ColorType"+                               , "ColorUIResource"+                               , "ComboBoxEditor"+                               , "ComboBoxModel"+                               , "ComboBoxUI"+                               , "ComboPopup"+                               , "CommandEnvironment"+                               , "Comment"+                               , "CommunicationException"+                               , "Comparable"+                               , "Comparator"+                               , "Compiler"+                               , "CompletionStatus"+                               , "CompletionStatusHelper"+                               , "Component"+                               , "ComponentAdapter"+                               , "ComponentColorModel"+                               , "ComponentEvent"+                               , "ComponentIdHelper"+                               , "ComponentInputMap"+                               , "ComponentInputMapUIResource"+                               , "ComponentListener"+                               , "ComponentOrientation"+                               , "ComponentSampleModel"+                               , "ComponentUI"+                               , "ComponentView"+                               , "Composite"+                               , "CompositeContext"+                               , "CompositeName"+                               , "CompositeView"+                               , "CompoundBorder"+                               , "CompoundBorderUIResource"+                               , "CompoundControl"+                               , "CompoundEdit"+                               , "CompoundName"+                               , "Compression"+                               , "ConcurrentModificationException"+                               , "Configuration"+                               , "ConfigurationException"+                               , "ConfirmationCallback"+                               , "ConnectException"+                               , "ConnectIOException"+                               , "Connection"+                               , "ConnectionEvent"+                               , "ConnectionEventListener"+                               , "ConnectionPendingException"+                               , "ConnectionPoolDataSource"+                               , "ConsoleHandler"+                               , "Constraints"+                               , "Constructor"+                               , "Container"+                               , "ContainerAdapter"+                               , "ContainerEvent"+                               , "ContainerListener"+                               , "ContainerOrderFocusTraversalPolicy"+                               , "Content"+                               , "ContentHandler"+                               , "ContentHandlerFactory"+                               , "ContentModel"+                               , "Context"+                               , "ContextList"+                               , "ContextNotEmptyException"+                               , "ContextualRenderedImageFactory"+                               , "Control"+                               , "ControlFactory"+                               , "ControllerEventListener"+                               , "ConvolveOp"+                               , "CookieHolder"+                               , "Copies"+                               , "CopiesSupported"+                               , "CopyAction"+                               , "CredentialExpiredException"+                               , "CropImageFilter"+                               , "CubicCurve2D"+                               , "Currency"+                               , "Current"+                               , "CurrentHelper"+                               , "CurrentHolder"+                               , "CurrentOperations"+                               , "Cursor"+                               , "CustomMarshal"+                               , "CustomValue"+                               , "Customizer"+                               , "CutAction"+                               , "DATA_CONVERSION"+                               , "DESKeySpec"+                               , "DESedeKeySpec"+                               , "DGC"+                               , "DHGenParameterSpec"+                               , "DHKey"+                               , "DHParameterSpec"+                               , "DHPrivateKey"+                               , "DHPrivateKeySpec"+                               , "DHPublicKey"+                               , "DHPublicKeySpec"+                               , "DOMException"+                               , "DOMImplementation"+                               , "DOMLocator"+                               , "DOMResult"+                               , "DOMSource"+                               , "DSAKey"+                               , "DSAKeyPairGenerator"+                               , "DSAParameterSpec"+                               , "DSAParams"+                               , "DSAPrivateKey"+                               , "DSAPrivateKeySpec"+                               , "DSAPublicKey"+                               , "DSAPublicKeySpec"+                               , "DTD"+                               , "DTDConstants"+                               , "DTDHandler"+                               , "DataBuffer"+                               , "DataBufferByte"+                               , "DataBufferDouble"+                               , "DataBufferFloat"+                               , "DataBufferInt"+                               , "DataBufferShort"+                               , "DataBufferUShort"+                               , "DataFlavor"+                               , "DataFormatException"+                               , "DataInput"+                               , "DataInputStream"+                               , "DataLine"+                               , "DataOutput"+                               , "DataOutputStream"+                               , "DataSource"+                               , "DataTruncation"+                               , "DatabaseMetaData"+                               , "DatagramChannel"+                               , "DatagramPacket"+                               , "DatagramSocket"+                               , "DatagramSocketImpl"+                               , "DatagramSocketImplFactory"+                               , "Date"+                               , "DateEditor"+                               , "DateFormat"+                               , "DateFormatSymbols"+                               , "DateFormatter"+                               , "DateTimeAtCompleted"+                               , "DateTimeAtCreation"+                               , "DateTimeAtProcessing"+                               , "DateTimeSyntax"+                               , "DebugGraphics"+                               , "DecimalFormat"+                               , "DecimalFormatSymbols"+                               , "DeclHandler"+                               , "DefaultBoundedRangeModel"+                               , "DefaultButtonModel"+                               , "DefaultCaret"+                               , "DefaultCellEditor"+                               , "DefaultColorSelectionModel"+                               , "DefaultComboBoxModel"+                               , "DefaultDesktopManager"+                               , "DefaultEditor"+                               , "DefaultEditorKit"+                               , "DefaultFocusManager"+                               , "DefaultFocusTraversalPolicy"+                               , "DefaultFormatter"+                               , "DefaultFormatterFactory"+                               , "DefaultHandler"+                               , "DefaultHighlightPainter"+                               , "DefaultHighlighter"+                               , "DefaultKeyTypedAction"+                               , "DefaultKeyboardFocusManager"+                               , "DefaultListCellRenderer"+                               , "DefaultListModel"+                               , "DefaultListSelectionModel"+                               , "DefaultMenuLayout"+                               , "DefaultMetalTheme"+                               , "DefaultMutableTreeNode"+                               , "DefaultPersistenceDelegate"+                               , "DefaultSelectionType"+                               , "DefaultSingleSelectionModel"+                               , "DefaultStyledDocument"+                               , "DefaultTableCellRenderer"+                               , "DefaultTableColumnModel"+                               , "DefaultTableModel"+                               , "DefaultTextUI"+                               , "DefaultTreeCellEditor"+                               , "DefaultTreeCellRenderer"+                               , "DefaultTreeModel"+                               , "DefaultTreeSelectionModel"+                               , "DefinitionKind"+                               , "DefinitionKindHelper"+                               , "Deflater"+                               , "DeflaterOutputStream"+                               , "Delegate"+                               , "DelegationPermission"+                               , "DesignMode"+                               , "DesktopIconUI"+                               , "DesktopManager"+                               , "DesktopPaneUI"+                               , "Destination"+                               , "DestinationType"+                               , "DestroyFailedException"+                               , "Destroyable"+                               , "Dialog"+                               , "DialogType"+                               , "Dictionary"+                               , "DigestException"+                               , "DigestInputStream"+                               , "DigestOutputStream"+                               , "Dimension"+                               , "Dimension2D"+                               , "DimensionUIResource"+                               , "DirContext"+                               , "DirObjectFactory"+                               , "DirStateFactory"+                               , "DirectColorModel"+                               , "DirectoryManager"+                               , "DisplayMode"+                               , "DnDConstants"+                               , "Doc"+                               , "DocAttribute"+                               , "DocAttributeSet"+                               , "DocFlavor"+                               , "DocPrintJob"+                               , "Document"+                               , "DocumentBuilder"+                               , "DocumentBuilderFactory"+                               , "DocumentEvent"+                               , "DocumentFilter"+                               , "DocumentFragment"+                               , "DocumentHandler"+                               , "DocumentListener"+                               , "DocumentName"+                               , "DocumentParser"+                               , "DocumentType"+                               , "DomainCombiner"+                               , "DomainManager"+                               , "DomainManagerOperations"+                               , "Double"+                               , "DoubleBuffer"+                               , "DoubleHolder"+                               , "DoubleSeqHelper"+                               , "DoubleSeqHolder"+                               , "DragGestureEvent"+                               , "DragGestureListener"+                               , "DragGestureRecognizer"+                               , "DragSource"+                               , "DragSourceAdapter"+                               , "DragSourceContext"+                               , "DragSourceDragEvent"+                               , "DragSourceDropEvent"+                               , "DragSourceEvent"+                               , "DragSourceListener"+                               , "DragSourceMotionListener"+                               , "Driver"+                               , "DriverManager"+                               , "DriverPropertyInfo"+                               , "DropTarget"+                               , "DropTargetAdapter"+                               , "DropTargetAutoScroller"+                               , "DropTargetContext"+                               , "DropTargetDragEvent"+                               , "DropTargetDropEvent"+                               , "DropTargetEvent"+                               , "DropTargetListener"+                               , "DuplicateName"+                               , "DuplicateNameHelper"+                               , "DynAny"+                               , "DynAnyFactory"+                               , "DynAnyFactoryHelper"+                               , "DynAnyFactoryOperations"+                               , "DynAnyHelper"+                               , "DynAnyOperations"+                               , "DynAnySeqHelper"+                               , "DynArray"+                               , "DynArrayHelper"+                               , "DynArrayOperations"+                               , "DynEnum"+                               , "DynEnumHelper"+                               , "DynEnumOperations"+                               , "DynFixed"+                               , "DynFixedHelper"+                               , "DynFixedOperations"+                               , "DynSequence"+                               , "DynSequenceHelper"+                               , "DynSequenceOperations"+                               , "DynStruct"+                               , "DynStructHelper"+                               , "DynStructOperations"+                               , "DynUnion"+                               , "DynUnionHelper"+                               , "DynUnionOperations"+                               , "DynValue"+                               , "DynValueBox"+                               , "DynValueBoxOperations"+                               , "DynValueCommon"+                               , "DynValueCommonOperations"+                               , "DynValueHelper"+                               , "DynValueOperations"+                               , "DynamicImplementation"+                               , "DynamicUtilTreeNode"+                               , "ENCODING_CDR_ENCAPS"+                               , "EOFException"+                               , "EditorKit"+                               , "Element"+                               , "ElementChange"+                               , "ElementEdit"+                               , "ElementIterator"+                               , "ElementSpec"+                               , "Ellipse2D"+                               , "EmptyBorder"+                               , "EmptyBorderUIResource"+                               , "EmptySelectionModel"+                               , "EmptyStackException"+                               , "EncodedKeySpec"+                               , "Encoder"+                               , "Encoding"+                               , "EncryptedPrivateKeyInfo"+                               , "Engineering"+                               , "Entity"+                               , "EntityReference"+                               , "EntityResolver"+                               , "Entry"+                               , "EnumControl"+                               , "EnumSyntax"+                               , "Enumeration"+                               , "Environment"+                               , "Error"+                               , "ErrorHandler"+                               , "ErrorListener"+                               , "ErrorManager"+                               , "EtchedBorder"+                               , "EtchedBorderUIResource"+                               , "Event"+                               , "EventContext"+                               , "EventDirContext"+                               , "EventHandler"+                               , "EventListener"+                               , "EventListenerList"+                               , "EventListenerProxy"+                               , "EventObject"+                               , "EventQueue"+                               , "EventSetDescriptor"+                               , "EventType"+                               , "Exception"+                               , "ExceptionInInitializerError"+                               , "ExceptionList"+                               , "ExceptionListener"+                               , "ExemptionMechanism"+                               , "ExemptionMechanismException"+                               , "ExemptionMechanismSpi"+                               , "ExpandVetoException"+                               , "ExportException"+                               , "Expression"+                               , "ExtendedRequest"+                               , "ExtendedResponse"+                               , "Externalizable"+                               , "FREE_MEM"+                               , "FactoryConfigurationError"+                               , "FailedLoginException"+                               , "FeatureDescriptor"+                               , "Fidelity"+                               , "Field"+                               , "FieldBorder"+                               , "FieldNameHelper"+                               , "FieldPosition"+                               , "FieldView"+                               , "File"+                               , "FileCacheImageInputStream"+                               , "FileCacheImageOutputStream"+                               , "FileChannel"+                               , "FileChooserUI"+                               , "FileDescriptor"+                               , "FileDialog"+                               , "FileFilter"+                               , "FileHandler"+                               , "FileIcon16"+                               , "FileImageInputStream"+                               , "FileImageOutputStream"+                               , "FileInputStream"+                               , "FileLock"+                               , "FileLockInterruptionException"+                               , "FileNameMap"+                               , "FileNotFoundException"+                               , "FileOutputStream"+                               , "FilePermission"+                               , "FileReader"+                               , "FileSystemView"+                               , "FileView"+                               , "FileWriter"+                               , "FilenameFilter"+                               , "Filler"+                               , "Filter"+                               , "FilterBypass"+                               , "FilterInputStream"+                               , "FilterOutputStream"+                               , "FilterReader"+                               , "FilterWriter"+                               , "FilteredImageSource"+                               , "Finishings"+                               , "FixedHeightLayoutCache"+                               , "FixedHolder"+                               , "FlatteningPathIterator"+                               , "FlavorException"+                               , "FlavorMap"+                               , "FlavorTable"+                               , "FlipContents"+                               , "Float"+                               , "FloatBuffer"+                               , "FloatControl"+                               , "FloatHolder"+                               , "FloatSeqHelper"+                               , "FloatSeqHolder"+                               , "FlowLayout"+                               , "FlowStrategy"+                               , "FlowView"+                               , "Flush3DBorder"+                               , "FocusAdapter"+                               , "FocusEvent"+                               , "FocusListener"+                               , "FocusManager"+                               , "FocusTraversalPolicy"+                               , "FolderIcon16"+                               , "Font"+                               , "FontAttribute"+                               , "FontConstants"+                               , "FontFamilyAction"+                               , "FontFormatException"+                               , "FontMetrics"+                               , "FontRenderContext"+                               , "FontSizeAction"+                               , "FontUIResource"+                               , "ForegroundAction"+                               , "FormView"+                               , "Format"+                               , "FormatConversionProvider"+                               , "FormatMismatch"+                               , "FormatMismatchHelper"+                               , "Formatter"+                               , "ForwardRequest"+                               , "ForwardRequestHelper"+                               , "Frame"+                               , "GSSContext"+                               , "GSSCredential"+                               , "GSSException"+                               , "GSSManager"+                               , "GSSName"+                               , "GZIPInputStream"+                               , "GZIPOutputStream"+                               , "GapContent"+                               , "GatheringByteChannel"+                               , "GeneralPath"+                               , "GeneralSecurityException"+                               , "GetField"+                               , "GlyphJustificationInfo"+                               , "GlyphMetrics"+                               , "GlyphPainter"+                               , "GlyphVector"+                               , "GlyphView"+                               , "GradientPaint"+                               , "GraphicAttribute"+                               , "Graphics"+                               , "Graphics2D"+                               , "GraphicsConfigTemplate"+                               , "GraphicsConfiguration"+                               , "GraphicsDevice"+                               , "GraphicsEnvironment"+                               , "GrayFilter"+                               , "GregorianCalendar"+                               , "GridBagConstraints"+                               , "GridBagLayout"+                               , "GridLayout"+                               , "Group"+                               , "Guard"+                               , "GuardedObject"+                               , "HTML"+                               , "HTMLDocument"+                               , "HTMLEditorKit"+                               , "HTMLFrameHyperlinkEvent"+                               , "HTMLWriter"+                               , "Handler"+                               , "HandlerBase"+                               , "HandshakeCompletedEvent"+                               , "HandshakeCompletedListener"+                               , "HasControls"+                               , "HashAttributeSet"+                               , "HashDocAttributeSet"+                               , "HashMap"+                               , "HashPrintJobAttributeSet"+                               , "HashPrintRequestAttributeSet"+                               , "HashPrintServiceAttributeSet"+                               , "HashSet"+                               , "Hashtable"+                               , "HeadlessException"+                               , "HierarchyBoundsAdapter"+                               , "HierarchyBoundsListener"+                               , "HierarchyEvent"+                               , "HierarchyListener"+                               , "Highlight"+                               , "HighlightPainter"+                               , "Highlighter"+                               , "HostnameVerifier"+                               , "HttpURLConnection"+                               , "HttpsURLConnection"+                               , "HyperlinkEvent"+                               , "HyperlinkListener"+                               , "ICC_ColorSpace"+                               , "ICC_Profile"+                               , "ICC_ProfileGray"+                               , "ICC_ProfileRGB"+                               , "IDLEntity"+                               , "IDLType"+                               , "IDLTypeHelper"+                               , "IDLTypeOperations"+                               , "ID_ASSIGNMENT_POLICY_ID"+                               , "ID_UNIQUENESS_POLICY_ID"+                               , "IIOByteBuffer"+                               , "IIOException"+                               , "IIOImage"+                               , "IIOInvalidTreeException"+                               , "IIOMetadata"+                               , "IIOMetadataController"+                               , "IIOMetadataFormat"+                               , "IIOMetadataFormatImpl"+                               , "IIOMetadataNode"+                               , "IIOParam"+                               , "IIOParamController"+                               , "IIOReadProgressListener"+                               , "IIOReadUpdateListener"+                               , "IIOReadWarningListener"+                               , "IIORegistry"+                               , "IIOServiceProvider"+                               , "IIOWriteProgressListener"+                               , "IIOWriteWarningListener"+                               , "IMPLICIT_ACTIVATION_POLICY_ID"+                               , "IMP_LIMIT"+                               , "INITIALIZE"+                               , "INPUT_STREAM"+                               , "INTERNAL"+                               , "INTF_REPOS"+                               , "INVALID_TRANSACTION"+                               , "INV_FLAG"+                               , "INV_IDENT"+                               , "INV_OBJREF"+                               , "INV_POLICY"+                               , "IOException"+                               , "IOR"+                               , "IORHelper"+                               , "IORHolder"+                               , "IORInfo"+                               , "IORInfoOperations"+                               , "IORInterceptor"+                               , "IORInterceptorOperations"+                               , "IRObject"+                               , "IRObjectOperations"+                               , "ISO"+                               , "Icon"+                               , "IconUIResource"+                               , "IconView"+                               , "IdAssignmentPolicy"+                               , "IdAssignmentPolicyOperations"+                               , "IdAssignmentPolicyValue"+                               , "IdUniquenessPolicy"+                               , "IdUniquenessPolicyOperations"+                               , "IdUniquenessPolicyValue"+                               , "IdentifierHelper"+                               , "Identity"+                               , "IdentityHashMap"+                               , "IdentityScope"+                               , "IllegalAccessError"+                               , "IllegalAccessException"+                               , "IllegalArgumentException"+                               , "IllegalBlockSizeException"+                               , "IllegalBlockingModeException"+                               , "IllegalCharsetNameException"+                               , "IllegalComponentStateException"+                               , "IllegalMonitorStateException"+                               , "IllegalPathStateException"+                               , "IllegalSelectorException"+                               , "IllegalStateException"+                               , "IllegalThreadStateException"+                               , "Image"+                               , "ImageCapabilities"+                               , "ImageConsumer"+                               , "ImageFilter"+                               , "ImageGraphicAttribute"+                               , "ImageIO"+                               , "ImageIcon"+                               , "ImageInputStream"+                               , "ImageInputStreamImpl"+                               , "ImageInputStreamSpi"+                               , "ImageObserver"+                               , "ImageOutputStream"+                               , "ImageOutputStreamImpl"+                               , "ImageOutputStreamSpi"+                               , "ImageProducer"+                               , "ImageReadParam"+                               , "ImageReader"+                               , "ImageReaderSpi"+                               , "ImageReaderWriterSpi"+                               , "ImageTranscoder"+                               , "ImageTranscoderSpi"+                               , "ImageTypeSpecifier"+                               , "ImageView"+                               , "ImageWriteParam"+                               , "ImageWriter"+                               , "ImageWriterSpi"+                               , "ImagingOpException"+                               , "ImplicitActivationPolicy"+                               , "ImplicitActivationPolicyOperations"+                               , "ImplicitActivationPolicyValue"+                               , "IncompatibleClassChangeError"+                               , "InconsistentTypeCode"+                               , "InconsistentTypeCodeHelper"+                               , "IndexColorModel"+                               , "IndexOutOfBoundsException"+                               , "IndexedPropertyDescriptor"+                               , "IndirectionException"+                               , "Inet4Address"+                               , "Inet6Address"+                               , "InetAddress"+                               , "InetSocketAddress"+                               , "Inflater"+                               , "InflaterInputStream"+                               , "Info"+                               , "InheritableThreadLocal"+                               , "InitialContext"+                               , "InitialContextFactory"+                               , "InitialContextFactoryBuilder"+                               , "InitialDirContext"+                               , "InitialLdapContext"+                               , "InlineView"+                               , "InputContext"+                               , "InputEvent"+                               , "InputMap"+                               , "InputMapUIResource"+                               , "InputMethod"+                               , "InputMethodContext"+                               , "InputMethodDescriptor"+                               , "InputMethodEvent"+                               , "InputMethodHighlight"+                               , "InputMethodListener"+                               , "InputMethodRequests"+                               , "InputSource"+                               , "InputStream"+                               , "InputStreamReader"+                               , "InputSubset"+                               , "InputVerifier"+                               , "InsertBreakAction"+                               , "InsertContentAction"+                               , "InsertHTMLTextAction"+                               , "InsertTabAction"+                               , "Insets"+                               , "InsetsUIResource"+                               , "InstantiationError"+                               , "InstantiationException"+                               , "Instrument"+                               , "InsufficientResourcesException"+                               , "IntBuffer"+                               , "IntHolder"+                               , "Integer"+                               , "IntegerSyntax"+                               , "Interceptor"+                               , "InterceptorOperations"+                               , "InternalError"+                               , "InternalFrameAdapter"+                               , "InternalFrameBorder"+                               , "InternalFrameEvent"+                               , "InternalFrameFocusTraversalPolicy"+                               , "InternalFrameListener"+                               , "InternalFrameUI"+                               , "InternationalFormatter"+                               , "InterruptedException"+                               , "InterruptedIOException"+                               , "InterruptedNamingException"+                               , "InterruptibleChannel"+                               , "IntrospectionException"+                               , "Introspector"+                               , "Invalid"+                               , "InvalidAddress"+                               , "InvalidAddressHelper"+                               , "InvalidAddressHolder"+                               , "InvalidAlgorithmParameterException"+                               , "InvalidAttributeIdentifierException"+                               , "InvalidAttributeValueException"+                               , "InvalidAttributesException"+                               , "InvalidClassException"+                               , "InvalidDnDOperationException"+                               , "InvalidKeyException"+                               , "InvalidKeySpecException"+                               , "InvalidMarkException"+                               , "InvalidMidiDataException"+                               , "InvalidName"+                               , "InvalidNameException"+                               , "InvalidNameHelper"+                               , "InvalidNameHolder"+                               , "InvalidObjectException"+                               , "InvalidParameterException"+                               , "InvalidParameterSpecException"+                               , "InvalidPolicy"+                               , "InvalidPolicyHelper"+                               , "InvalidPreferencesFormatException"+                               , "InvalidSearchControlsException"+                               , "InvalidSearchFilterException"+                               , "InvalidSeq"+                               , "InvalidSlot"+                               , "InvalidSlotHelper"+                               , "InvalidTransactionException"+                               , "InvalidTypeForEncoding"+                               , "InvalidTypeForEncodingHelper"+                               , "InvalidValue"+                               , "InvalidValueHelper"+                               , "InvocationEvent"+                               , "InvocationHandler"+                               , "InvocationTargetException"+                               , "InvokeHandler"+                               , "IstringHelper"+                               , "ItalicAction"+                               , "ItemEvent"+                               , "ItemListener"+                               , "ItemSelectable"+                               , "Iterator"+                               , "IvParameterSpec"+                               , "JApplet"+                               , "JButton"+                               , "JCheckBox"+                               , "JCheckBoxMenuItem"+                               , "JColorChooser"+                               , "JComboBox"+                               , "JComponent"+                               , "JDesktopIcon"+                               , "JDesktopPane"+                               , "JDialog"+                               , "JEditorPane"+                               , "JFileChooser"+                               , "JFormattedTextField"+                               , "JFrame"+                               , "JIS"+                               , "JInternalFrame"+                               , "JLabel"+                               , "JLayeredPane"+                               , "JList"+                               , "JMenu"+                               , "JMenuBar"+                               , "JMenuItem"+                               , "JOptionPane"+                               , "JPEGHuffmanTable"+                               , "JPEGImageReadParam"+                               , "JPEGImageWriteParam"+                               , "JPEGQTable"+                               , "JPanel"+                               , "JPasswordField"+                               , "JPopupMenu"+                               , "JProgressBar"+                               , "JRadioButton"+                               , "JRadioButtonMenuItem"+                               , "JRootPane"+                               , "JScrollBar"+                               , "JScrollPane"+                               , "JSeparator"+                               , "JSlider"+                               , "JSpinner"+                               , "JSplitPane"+                               , "JTabbedPane"+                               , "JTable"+                               , "JTableHeader"+                               , "JTextArea"+                               , "JTextComponent"+                               , "JTextField"+                               , "JTextPane"+                               , "JToggleButton"+                               , "JToolBar"+                               , "JToolTip"+                               , "JTree"+                               , "JViewport"+                               , "JWindow"+                               , "JarEntry"+                               , "JarException"+                               , "JarFile"+                               , "JarInputStream"+                               , "JarOutputStream"+                               , "JarURLConnection"+                               , "JobAttributes"+                               , "JobHoldUntil"+                               , "JobImpressions"+                               , "JobImpressionsCompleted"+                               , "JobImpressionsSupported"+                               , "JobKOctets"+                               , "JobKOctetsProcessed"+                               , "JobKOctetsSupported"+                               , "JobMediaSheets"+                               , "JobMediaSheetsCompleted"+                               , "JobMediaSheetsSupported"+                               , "JobMessageFromOperator"+                               , "JobName"+                               , "JobOriginatingUserName"+                               , "JobPriority"+                               , "JobPrioritySupported"+                               , "JobSheets"+                               , "JobState"+                               , "JobStateReason"+                               , "JobStateReasons"+                               , "KerberosKey"+                               , "KerberosPrincipal"+                               , "KerberosTicket"+                               , "Kernel"+                               , "Key"+                               , "KeyAdapter"+                               , "KeyAgreement"+                               , "KeyAgreementSpi"+                               , "KeyBinding"+                               , "KeyEvent"+                               , "KeyEventDispatcher"+                               , "KeyEventPostProcessor"+                               , "KeyException"+                               , "KeyFactory"+                               , "KeyFactorySpi"+                               , "KeyGenerator"+                               , "KeyGeneratorSpi"+                               , "KeyListener"+                               , "KeyManagementException"+                               , "KeyManager"+                               , "KeyManagerFactory"+                               , "KeyManagerFactorySpi"+                               , "KeyPair"+                               , "KeyPairGenerator"+                               , "KeyPairGeneratorSpi"+                               , "KeySelectionManager"+                               , "KeySpec"+                               , "KeyStore"+                               , "KeyStoreException"+                               , "KeyStoreSpi"+                               , "KeyStroke"+                               , "KeyboardFocusManager"+                               , "Keymap"+                               , "LDAPCertStoreParameters"+                               , "LIFESPAN_POLICY_ID"+                               , "LOCATION_FORWARD"+                               , "Label"+                               , "LabelUI"+                               , "LabelView"+                               , "LanguageCallback"+                               , "LastOwnerException"+                               , "LayerPainter"+                               , "LayeredHighlighter"+                               , "LayoutFocusTraversalPolicy"+                               , "LayoutManager"+                               , "LayoutManager2"+                               , "LayoutQueue"+                               , "LazyInputMap"+                               , "LazyValue"+                               , "LdapContext"+                               , "LdapReferralException"+                               , "Lease"+                               , "Level"+                               , "LexicalHandler"+                               , "LifespanPolicy"+                               , "LifespanPolicyOperations"+                               , "LifespanPolicyValue"+                               , "LimitExceededException"+                               , "Line"+                               , "Line2D"+                               , "LineBorder"+                               , "LineBorderUIResource"+                               , "LineBreakMeasurer"+                               , "LineEvent"+                               , "LineListener"+                               , "LineMetrics"+                               , "LineNumberInputStream"+                               , "LineNumberReader"+                               , "LineUnavailableException"+                               , "LinkController"+                               , "LinkException"+                               , "LinkLoopException"+                               , "LinkRef"+                               , "LinkageError"+                               , "LinkedHashMap"+                               , "LinkedHashSet"+                               , "LinkedList"+                               , "List"+                               , "ListCellRenderer"+                               , "ListDataEvent"+                               , "ListDataListener"+                               , "ListEditor"+                               , "ListIterator"+                               , "ListModel"+                               , "ListPainter"+                               , "ListResourceBundle"+                               , "ListSelectionEvent"+                               , "ListSelectionListener"+                               , "ListSelectionModel"+                               , "ListUI"+                               , "ListView"+                               , "LoaderHandler"+                               , "LocalObject"+                               , "Locale"+                               , "LocateRegistry"+                               , "Locator"+                               , "LocatorImpl"+                               , "LogManager"+                               , "LogRecord"+                               , "LogStream"+                               , "Logger"+                               , "LoggingPermission"+                               , "LoginContext"+                               , "LoginException"+                               , "LoginModule"+                               , "LoginModuleControlFlag"+                               , "Long"+                               , "LongBuffer"+                               , "LongHolder"+                               , "LongLongSeqHelper"+                               , "LongLongSeqHolder"+                               , "LongSeqHelper"+                               , "LongSeqHolder"+                               , "LookAndFeel"+                               , "LookAndFeelInfo"+                               , "LookupOp"+                               , "LookupTable"+                               , "MARSHAL"+                               , "Mac"+                               , "MacSpi"+                               , "MalformedInputException"+                               , "MalformedLinkException"+                               , "MalformedURLException"+                               , "ManagerFactoryParameters"+                               , "Manifest"+                               , "Map"+                               , "MapMode"+                               , "MappedByteBuffer"+                               , "MarginBorder"+                               , "MarshalException"+                               , "MarshalledObject"+                               , "MaskFormatter"+                               , "Matcher"+                               , "Math"+                               , "MatteBorder"+                               , "MatteBorderUIResource"+                               , "Media"+                               , "MediaName"+                               , "MediaPrintableArea"+                               , "MediaSize"+                               , "MediaSizeName"+                               , "MediaTracker"+                               , "MediaTray"+                               , "MediaType"+                               , "Member"+                               , "MemoryCacheImageInputStream"+                               , "MemoryCacheImageOutputStream"+                               , "MemoryHandler"+                               , "MemoryImageSource"+                               , "Menu"+                               , "MenuBar"+                               , "MenuBarBorder"+                               , "MenuBarUI"+                               , "MenuComponent"+                               , "MenuContainer"+                               , "MenuDragMouseEvent"+                               , "MenuDragMouseListener"+                               , "MenuElement"+                               , "MenuEvent"+                               , "MenuItem"+                               , "MenuItemBorder"+                               , "MenuItemUI"+                               , "MenuKeyEvent"+                               , "MenuKeyListener"+                               , "MenuListener"+                               , "MenuSelectionManager"+                               , "MenuShortcut"+                               , "MessageDigest"+                               , "MessageDigestSpi"+                               , "MessageFormat"+                               , "MessageProp"+                               , "MetaEventListener"+                               , "MetaMessage"+                               , "MetalBorders"+                               , "MetalButtonUI"+                               , "MetalCheckBoxIcon"+                               , "MetalCheckBoxUI"+                               , "MetalComboBoxButton"+                               , "MetalComboBoxEditor"+                               , "MetalComboBoxIcon"+                               , "MetalComboBoxUI"+                               , "MetalDesktopIconUI"+                               , "MetalFileChooserUI"+                               , "MetalIconFactory"+                               , "MetalInternalFrameTitlePane"+                               , "MetalInternalFrameUI"+                               , "MetalLabelUI"+                               , "MetalLookAndFeel"+                               , "MetalPopupMenuSeparatorUI"+                               , "MetalProgressBarUI"+                               , "MetalRadioButtonUI"+                               , "MetalRootPaneUI"+                               , "MetalScrollBarUI"+                               , "MetalScrollButton"+                               , "MetalScrollPaneUI"+                               , "MetalSeparatorUI"+                               , "MetalSliderUI"+                               , "MetalSplitPaneUI"+                               , "MetalTabbedPaneUI"+                               , "MetalTextFieldUI"+                               , "MetalTheme"+                               , "MetalToggleButtonUI"+                               , "MetalToolBarUI"+                               , "MetalToolTipUI"+                               , "MetalTreeUI"+                               , "Method"+                               , "MethodDescriptor"+                               , "MidiChannel"+                               , "MidiDevice"+                               , "MidiDeviceProvider"+                               , "MidiEvent"+                               , "MidiFileFormat"+                               , "MidiFileReader"+                               , "MidiFileWriter"+                               , "MidiMessage"+                               , "MidiSystem"+                               , "MidiUnavailableException"+                               , "MimeTypeParseException"+                               , "MinimalHTMLWriter"+                               , "MissingResourceException"+                               , "Mixer"+                               , "MixerProvider"+                               , "ModificationItem"+                               , "Modifier"+                               , "MouseAdapter"+                               , "MouseDragGestureRecognizer"+                               , "MouseEvent"+                               , "MouseInputAdapter"+                               , "MouseInputListener"+                               , "MouseListener"+                               , "MouseMotionAdapter"+                               , "MouseMotionListener"+                               , "MouseWheelEvent"+                               , "MouseWheelListener"+                               , "MultiButtonUI"+                               , "MultiColorChooserUI"+                               , "MultiComboBoxUI"+                               , "MultiDesktopIconUI"+                               , "MultiDesktopPaneUI"+                               , "MultiDoc"+                               , "MultiDocPrintJob"+                               , "MultiDocPrintService"+                               , "MultiFileChooserUI"+                               , "MultiInternalFrameUI"+                               , "MultiLabelUI"+                               , "MultiListUI"+                               , "MultiLookAndFeel"+                               , "MultiMenuBarUI"+                               , "MultiMenuItemUI"+                               , "MultiOptionPaneUI"+                               , "MultiPanelUI"+                               , "MultiPixelPackedSampleModel"+                               , "MultiPopupMenuUI"+                               , "MultiProgressBarUI"+                               , "MultiRootPaneUI"+                               , "MultiScrollBarUI"+                               , "MultiScrollPaneUI"+                               , "MultiSeparatorUI"+                               , "MultiSliderUI"+                               , "MultiSpinnerUI"+                               , "MultiSplitPaneUI"+                               , "MultiTabbedPaneUI"+                               , "MultiTableHeaderUI"+                               , "MultiTableUI"+                               , "MultiTextUI"+                               , "MultiToolBarUI"+                               , "MultiToolTipUI"+                               , "MultiTreeUI"+                               , "MultiViewportUI"+                               , "MulticastSocket"+                               , "MultipleComponentProfileHelper"+                               , "MultipleComponentProfileHolder"+                               , "MultipleDocumentHandling"+                               , "MultipleDocumentHandlingType"+                               , "MultipleMaster"+                               , "MutableAttributeSet"+                               , "MutableComboBoxModel"+                               , "MutableTreeNode"+                               , "NA"+                               , "NO_IMPLEMENT"+                               , "NO_MEMORY"+                               , "NO_PERMISSION"+                               , "NO_RESOURCES"+                               , "NO_RESPONSE"+                               , "NVList"+                               , "Name"+                               , "NameAlreadyBoundException"+                               , "NameCallback"+                               , "NameClassPair"+                               , "NameComponent"+                               , "NameComponentHelper"+                               , "NameComponentHolder"+                               , "NameDynAnyPair"+                               , "NameDynAnyPairHelper"+                               , "NameDynAnyPairSeqHelper"+                               , "NameHelper"+                               , "NameHolder"+                               , "NameNotFoundException"+                               , "NameParser"+                               , "NameValuePair"+                               , "NameValuePairHelper"+                               , "NameValuePairSeqHelper"+                               , "NamedNodeMap"+                               , "NamedValue"+                               , "NamespaceChangeListener"+                               , "NamespaceSupport"+                               , "Naming"+                               , "NamingContext"+                               , "NamingContextExt"+                               , "NamingContextExtHelper"+                               , "NamingContextExtHolder"+                               , "NamingContextExtOperations"+                               , "NamingContextExtPOA"+                               , "NamingContextHelper"+                               , "NamingContextHolder"+                               , "NamingContextOperations"+                               , "NamingContextPOA"+                               , "NamingEnumeration"+                               , "NamingEvent"+                               , "NamingException"+                               , "NamingExceptionEvent"+                               , "NamingListener"+                               , "NamingManager"+                               , "NamingSecurityException"+                               , "NavigationFilter"+                               , "NegativeArraySizeException"+                               , "NetPermission"+                               , "NetworkInterface"+                               , "NoClassDefFoundError"+                               , "NoConnectionPendingException"+                               , "NoContext"+                               , "NoContextHelper"+                               , "NoInitialContextException"+                               , "NoPermissionException"+                               , "NoRouteToHostException"+                               , "NoServant"+                               , "NoServantHelper"+                               , "NoSuchAlgorithmException"+                               , "NoSuchAttributeException"+                               , "NoSuchElementException"+                               , "NoSuchFieldError"+                               , "NoSuchFieldException"+                               , "NoSuchMethodError"+                               , "NoSuchMethodException"+                               , "NoSuchObjectException"+                               , "NoSuchPaddingException"+                               , "NoSuchProviderException"+                               , "Node"+                               , "NodeChangeEvent"+                               , "NodeChangeListener"+                               , "NodeDimensions"+                               , "NodeList"+                               , "NonReadableChannelException"+                               , "NonWritableChannelException"+                               , "NoninvertibleTransformException"+                               , "NotActiveException"+                               , "NotBoundException"+                               , "NotContextException"+                               , "NotEmpty"+                               , "NotEmptyHelper"+                               , "NotEmptyHolder"+                               , "NotFound"+                               , "NotFoundHelper"+                               , "NotFoundHolder"+                               , "NotFoundReason"+                               , "NotFoundReasonHelper"+                               , "NotFoundReasonHolder"+                               , "NotOwnerException"+                               , "NotSerializableException"+                               , "NotYetBoundException"+                               , "NotYetConnectedException"+                               , "Notation"+                               , "NullCipher"+                               , "NullPointerException"+                               , "Number"+                               , "NumberEditor"+                               , "NumberFormat"+                               , "NumberFormatException"+                               , "NumberFormatter"+                               , "NumberOfDocuments"+                               , "NumberOfInterveningJobs"+                               , "NumberUp"+                               , "NumberUpSupported"+                               , "NumericShaper"+                               , "OBJECT_NOT_EXIST"+                               , "OBJ_ADAPTER"+                               , "OMGVMCID"+                               , "ORB"+                               , "ORBInitInfo"+                               , "ORBInitInfoOperations"+                               , "ORBInitializer"+                               , "ORBInitializerOperations"+                               , "ObjID"+                               , "Object"+                               , "ObjectAlreadyActive"+                               , "ObjectAlreadyActiveHelper"+                               , "ObjectChangeListener"+                               , "ObjectFactory"+                               , "ObjectFactoryBuilder"+                               , "ObjectHelper"+                               , "ObjectHolder"+                               , "ObjectIdHelper"+                               , "ObjectImpl"+                               , "ObjectInput"+                               , "ObjectInputStream"+                               , "ObjectInputValidation"+                               , "ObjectNotActive"+                               , "ObjectNotActiveHelper"+                               , "ObjectOutput"+                               , "ObjectOutputStream"+                               , "ObjectStreamClass"+                               , "ObjectStreamConstants"+                               , "ObjectStreamException"+                               , "ObjectStreamField"+                               , "ObjectView"+                               , "Observable"+                               , "Observer"+                               , "OctetSeqHelper"+                               , "OctetSeqHolder"+                               , "Oid"+                               , "OpenType"+                               , "Operation"+                               , "OperationNotSupportedException"+                               , "Option"+                               , "OptionDialogBorder"+                               , "OptionPaneUI"+                               , "OptionalDataException"+                               , "OrientationRequested"+                               , "OrientationRequestedType"+                               , "OriginType"+                               , "Other"+                               , "OutOfMemoryError"+                               , "OutputDeviceAssigned"+                               , "OutputKeys"+                               , "OutputStream"+                               , "OutputStreamWriter"+                               , "OverlappingFileLockException"+                               , "OverlayLayout"+                               , "Owner"+                               , "PBEKey"+                               , "PBEKeySpec"+                               , "PBEParameterSpec"+                               , "PDLOverrideSupported"+                               , "PERSIST_STORE"+                               , "PKCS8EncodedKeySpec"+                               , "PKIXBuilderParameters"+                               , "PKIXCertPathBuilderResult"+                               , "PKIXCertPathChecker"+                               , "PKIXCertPathValidatorResult"+                               , "PKIXParameters"+                               , "POA"+                               , "POAHelper"+                               , "POAManager"+                               , "POAManagerOperations"+                               , "POAOperations"+                               , "PRIVATE_MEMBER"+                               , "PSSParameterSpec"+                               , "PUBLIC_MEMBER"+                               , "Package"+                               , "PackedColorModel"+                               , "PageAttributes"+                               , "PageFormat"+                               , "PageRanges"+                               , "Pageable"+                               , "PagesPerMinute"+                               , "PagesPerMinuteColor"+                               , "Paint"+                               , "PaintContext"+                               , "PaintEvent"+                               , "PaletteBorder"+                               , "PaletteCloseIcon"+                               , "Panel"+                               , "PanelUI"+                               , "Paper"+                               , "ParagraphAttribute"+                               , "ParagraphConstants"+                               , "ParagraphView"+                               , "Parameter"+                               , "ParameterBlock"+                               , "ParameterDescriptor"+                               , "ParameterMetaData"+                               , "ParameterMode"+                               , "ParameterModeHelper"+                               , "ParameterModeHolder"+                               , "ParseException"+                               , "ParsePosition"+                               , "Parser"+                               , "ParserAdapter"+                               , "ParserCallback"+                               , "ParserConfigurationException"+                               , "ParserDelegator"+                               , "ParserFactory"+                               , "PartialResultException"+                               , "PasswordAuthentication"+                               , "PasswordCallback"+                               , "PasswordView"+                               , "PasteAction"+                               , "Patch"+                               , "PathIterator"+                               , "Pattern"+                               , "PatternSyntaxException"+                               , "Permission"+                               , "PermissionCollection"+                               , "Permissions"+                               , "PersistenceDelegate"+                               , "PhantomReference"+                               , "Pipe"+                               , "PipedInputStream"+                               , "PipedOutputStream"+                               , "PipedReader"+                               , "PipedWriter"+                               , "PixelGrabber"+                               , "PixelInterleavedSampleModel"+                               , "PlainDocument"+                               , "PlainView"+                               , "Point"+                               , "Point2D"+                               , "Policy"+                               , "PolicyError"+                               , "PolicyErrorCodeHelper"+                               , "PolicyErrorHelper"+                               , "PolicyErrorHolder"+                               , "PolicyFactory"+                               , "PolicyFactoryOperations"+                               , "PolicyHelper"+                               , "PolicyHolder"+                               , "PolicyListHelper"+                               , "PolicyListHolder"+                               , "PolicyNode"+                               , "PolicyOperations"+                               , "PolicyQualifierInfo"+                               , "PolicyTypeHelper"+                               , "Polygon"+                               , "PooledConnection"+                               , "Popup"+                               , "PopupFactory"+                               , "PopupMenu"+                               , "PopupMenuBorder"+                               , "PopupMenuEvent"+                               , "PopupMenuListener"+                               , "PopupMenuUI"+                               , "Port"+                               , "PortUnreachableException"+                               , "PortableRemoteObject"+                               , "PortableRemoteObjectDelegate"+                               , "Position"+                               , "PreferenceChangeEvent"+                               , "PreferenceChangeListener"+                               , "Preferences"+                               , "PreferencesFactory"+                               , "PreparedStatement"+                               , "PresentationDirection"+                               , "Principal"+                               , "PrincipalHolder"+                               , "PrintEvent"+                               , "PrintException"+                               , "PrintGraphics"+                               , "PrintJob"+                               , "PrintJobAdapter"+                               , "PrintJobAttribute"+                               , "PrintJobAttributeEvent"+                               , "PrintJobAttributeListener"+                               , "PrintJobAttributeSet"+                               , "PrintJobEvent"+                               , "PrintJobListener"+                               , "PrintQuality"+                               , "PrintQualityType"+                               , "PrintRequestAttribute"+                               , "PrintRequestAttributeSet"+                               , "PrintService"+                               , "PrintServiceAttribute"+                               , "PrintServiceAttributeEvent"+                               , "PrintServiceAttributeListener"+                               , "PrintServiceAttributeSet"+                               , "PrintServiceLookup"+                               , "PrintStream"+                               , "PrintWriter"+                               , "Printable"+                               , "PrinterAbortException"+                               , "PrinterException"+                               , "PrinterGraphics"+                               , "PrinterIOException"+                               , "PrinterInfo"+                               , "PrinterIsAcceptingJobs"+                               , "PrinterJob"+                               , "PrinterLocation"+                               , "PrinterMakeAndModel"+                               , "PrinterMessageFromOperator"+                               , "PrinterMoreInfo"+                               , "PrinterMoreInfoManufacturer"+                               , "PrinterName"+                               , "PrinterResolution"+                               , "PrinterState"+                               , "PrinterStateReason"+                               , "PrinterStateReasons"+                               , "PrinterURI"+                               , "PrivateCredentialPermission"+                               , "PrivateKey"+                               , "PrivilegedAction"+                               , "PrivilegedActionException"+                               , "PrivilegedExceptionAction"+                               , "Process"+                               , "ProcessingInstruction"+                               , "ProfileDataException"+                               , "ProfileIdHelper"+                               , "ProgressBarUI"+                               , "ProgressMonitor"+                               , "ProgressMonitorInputStream"+                               , "Properties"+                               , "PropertyChangeEvent"+                               , "PropertyChangeListener"+                               , "PropertyChangeListenerProxy"+                               , "PropertyChangeSupport"+                               , "PropertyDescriptor"+                               , "PropertyEditor"+                               , "PropertyEditorManager"+                               , "PropertyEditorSupport"+                               , "PropertyPermission"+                               , "PropertyResourceBundle"+                               , "PropertyVetoException"+                               , "ProtectionDomain"+                               , "ProtocolException"+                               , "Provider"+                               , "ProviderException"+                               , "Proxy"+                               , "ProxyLazyValue"+                               , "PublicKey"+                               , "PushbackInputStream"+                               , "PushbackReader"+                               , "PutField"+                               , "QuadCurve2D"+                               , "QueuedJobCount"+                               , "RC2ParameterSpec"+                               , "RC5ParameterSpec"+                               , "READER"+                               , "REQUEST_PROCESSING_POLICY_ID"+                               , "RGBImageFilter"+                               , "RMIClassLoader"+                               , "RMIClassLoaderSpi"+                               , "RMIClientSocketFactory"+                               , "RMIFailureHandler"+                               , "RMISecurityException"+                               , "RMISecurityManager"+                               , "RMIServerSocketFactory"+                               , "RMISocketFactory"+                               , "RSAKey"+                               , "RSAKeyGenParameterSpec"+                               , "RSAMultiPrimePrivateCrtKey"+                               , "RSAMultiPrimePrivateCrtKeySpec"+                               , "RSAOtherPrimeInfo"+                               , "RSAPrivateCrtKey"+                               , "RSAPrivateCrtKeySpec"+                               , "RSAPrivateKey"+                               , "RSAPrivateKeySpec"+                               , "RSAPublicKey"+                               , "RSAPublicKeySpec"+                               , "RTFEditorKit"+                               , "RadioButtonBorder"+                               , "Random"+                               , "RandomAccess"+                               , "RandomAccessFile"+                               , "Raster"+                               , "RasterFormatException"+                               , "RasterOp"+                               , "ReadOnlyBufferException"+                               , "ReadableByteChannel"+                               , "Reader"+                               , "Receiver"+                               , "Rectangle"+                               , "Rectangle2D"+                               , "RectangularShape"+                               , "Ref"+                               , "RefAddr"+                               , "Reference"+                               , "ReferenceQueue"+                               , "ReferenceUriSchemesSupported"+                               , "Referenceable"+                               , "ReferralException"+                               , "ReflectPermission"+                               , "RefreshFailedException"+                               , "Refreshable"+                               , "RegisterableService"+                               , "Registry"+                               , "RegistryHandler"+                               , "RemarshalException"+                               , "Remote"+                               , "RemoteCall"+                               , "RemoteException"+                               , "RemoteObject"+                               , "RemoteRef"+                               , "RemoteServer"+                               , "RemoteStub"+                               , "RenderContext"+                               , "RenderableImage"+                               , "RenderableImageOp"+                               , "RenderableImageProducer"+                               , "RenderedImage"+                               , "RenderedImageFactory"+                               , "Renderer"+                               , "RenderingHints"+                               , "RepaintManager"+                               , "ReplicateScaleFilter"+                               , "RepositoryIdHelper"+                               , "Request"+                               , "RequestInfo"+                               , "RequestInfoOperations"+                               , "RequestProcessingPolicy"+                               , "RequestProcessingPolicyOperations"+                               , "RequestProcessingPolicyValue"+                               , "RequestingUserName"+                               , "RescaleOp"+                               , "ResolutionSyntax"+                               , "ResolveResult"+                               , "Resolver"+                               , "ResourceBundle"+                               , "ResponseHandler"+                               , "Result"+                               , "ResultSet"+                               , "ResultSetMetaData"+                               , "ReverbType"+                               , "Robot"+                               , "RolloverButtonBorder"+                               , "RootPaneContainer"+                               , "RootPaneUI"+                               , "RoundRectangle2D"+                               , "RowMapper"+                               , "RowSet"+                               , "RowSetEvent"+                               , "RowSetInternal"+                               , "RowSetListener"+                               , "RowSetMetaData"+                               , "RowSetReader"+                               , "RowSetWriter"+                               , "RuleBasedCollator"+                               , "RunTime"+                               , "RunTimeOperations"+                               , "Runnable"+                               , "Runtime"+                               , "RuntimeException"+                               , "RuntimePermission"+                               , "SAXException"+                               , "SAXNotRecognizedException"+                               , "SAXNotSupportedException"+                               , "SAXParseException"+                               , "SAXParser"+                               , "SAXParserFactory"+                               , "SAXResult"+                               , "SAXSource"+                               , "SAXTransformerFactory"+                               , "SERVANT_RETENTION_POLICY_ID"+                               , "SERVICE_FORMATTED"+                               , "SQLData"+                               , "SQLException"+                               , "SQLInput"+                               , "SQLOutput"+                               , "SQLPermission"+                               , "SQLWarning"+                               , "SSLContext"+                               , "SSLContextSpi"+                               , "SSLException"+                               , "SSLHandshakeException"+                               , "SSLKeyException"+                               , "SSLPeerUnverifiedException"+                               , "SSLPermission"+                               , "SSLProtocolException"+                               , "SSLServerSocket"+                               , "SSLServerSocketFactory"+                               , "SSLSession"+                               , "SSLSessionBindingEvent"+                               , "SSLSessionBindingListener"+                               , "SSLSessionContext"+                               , "SSLSocket"+                               , "SSLSocketFactory"+                               , "STRING"+                               , "SUCCESSFUL"+                               , "SYNC_WITH_TRANSPORT"+                               , "SYSTEM_EXCEPTION"+                               , "SampleModel"+                               , "Savepoint"+                               , "ScatteringByteChannel"+                               , "SchemaViolationException"+                               , "ScrollBarUI"+                               , "ScrollPane"+                               , "ScrollPaneAdjustable"+                               , "ScrollPaneBorder"+                               , "ScrollPaneConstants"+                               , "ScrollPaneLayout"+                               , "ScrollPaneUI"+                               , "Scrollable"+                               , "Scrollbar"+                               , "SealedObject"+                               , "SearchControls"+                               , "SearchResult"+                               , "SecretKey"+                               , "SecretKeyFactory"+                               , "SecretKeyFactorySpi"+                               , "SecretKeySpec"+                               , "SecureClassLoader"+                               , "SecureRandom"+                               , "SecureRandomSpi"+                               , "Security"+                               , "SecurityException"+                               , "SecurityManager"+                               , "SecurityPermission"+                               , "Segment"+                               , "SelectableChannel"+                               , "SelectionKey"+                               , "Selector"+                               , "SelectorProvider"+                               , "Separator"+                               , "SeparatorUI"+                               , "Sequence"+                               , "SequenceInputStream"+                               , "Sequencer"+                               , "Serializable"+                               , "SerializablePermission"+                               , "Servant"+                               , "ServantActivator"+                               , "ServantActivatorHelper"+                               , "ServantActivatorOperations"+                               , "ServantActivatorPOA"+                               , "ServantAlreadyActive"+                               , "ServantAlreadyActiveHelper"+                               , "ServantLocator"+                               , "ServantLocatorHelper"+                               , "ServantLocatorOperations"+                               , "ServantLocatorPOA"+                               , "ServantManager"+                               , "ServantManagerOperations"+                               , "ServantNotActive"+                               , "ServantNotActiveHelper"+                               , "ServantObject"+                               , "ServantRetentionPolicy"+                               , "ServantRetentionPolicyOperations"+                               , "ServantRetentionPolicyValue"+                               , "ServerCloneException"+                               , "ServerError"+                               , "ServerException"+                               , "ServerNotActiveException"+                               , "ServerRef"+                               , "ServerRequest"+                               , "ServerRequestInfo"+                               , "ServerRequestInfoOperations"+                               , "ServerRequestInterceptor"+                               , "ServerRequestInterceptorOperations"+                               , "ServerRuntimeException"+                               , "ServerSocket"+                               , "ServerSocketChannel"+                               , "ServerSocketFactory"+                               , "ServiceContext"+                               , "ServiceContextHelper"+                               , "ServiceContextHolder"+                               , "ServiceContextListHelper"+                               , "ServiceContextListHolder"+                               , "ServiceDetail"+                               , "ServiceDetailHelper"+                               , "ServiceIdHelper"+                               , "ServiceInformation"+                               , "ServiceInformationHelper"+                               , "ServiceInformationHolder"+                               , "ServicePermission"+                               , "ServiceRegistry"+                               , "ServiceUI"+                               , "ServiceUIFactory"+                               , "ServiceUnavailableException"+                               , "Set"+                               , "SetOfIntegerSyntax"+                               , "SetOverrideType"+                               , "SetOverrideTypeHelper"+                               , "Severity"+                               , "Shape"+                               , "ShapeGraphicAttribute"+                               , "SheetCollate"+                               , "Short"+                               , "ShortBuffer"+                               , "ShortBufferException"+                               , "ShortHolder"+                               , "ShortLookupTable"+                               , "ShortMessage"+                               , "ShortSeqHelper"+                               , "ShortSeqHolder"+                               , "Sides"+                               , "SidesType"+                               , "Signature"+                               , "SignatureException"+                               , "SignatureSpi"+                               , "SignedObject"+                               , "Signer"+                               , "SimpleAttributeSet"+                               , "SimpleBeanInfo"+                               , "SimpleDateFormat"+                               , "SimpleDoc"+                               , "SimpleFormatter"+                               , "SimpleTimeZone"+                               , "SinglePixelPackedSampleModel"+                               , "SingleSelectionModel"+                               , "SinkChannel"+                               , "Size2DSyntax"+                               , "SizeLimitExceededException"+                               , "SizeRequirements"+                               , "SizeSequence"+                               , "Skeleton"+                               , "SkeletonMismatchException"+                               , "SkeletonNotFoundException"+                               , "SliderUI"+                               , "Socket"+                               , "SocketAddress"+                               , "SocketChannel"+                               , "SocketException"+                               , "SocketFactory"+                               , "SocketHandler"+                               , "SocketImpl"+                               , "SocketImplFactory"+                               , "SocketOptions"+                               , "SocketPermission"+                               , "SocketSecurityException"+                               , "SocketTimeoutException"+                               , "SoftBevelBorder"+                               , "SoftReference"+                               , "SortedMap"+                               , "SortedSet"+                               , "SortingFocusTraversalPolicy"+                               , "Soundbank"+                               , "SoundbankReader"+                               , "SoundbankResource"+                               , "Source"+                               , "SourceChannel"+                               , "SourceDataLine"+                               , "SourceLocator"+                               , "SpinnerDateModel"+                               , "SpinnerListModel"+                               , "SpinnerModel"+                               , "SpinnerNumberModel"+                               , "SpinnerUI"+                               , "SplitPaneBorder"+                               , "SplitPaneUI"+                               , "Spring"+                               , "SpringLayout"+                               , "Stack"+                               , "StackOverflowError"+                               , "StackTraceElement"+                               , "StartTlsRequest"+                               , "StartTlsResponse"+                               , "State"+                               , "StateEdit"+                               , "StateEditable"+                               , "StateFactory"+                               , "Statement"+                               , "StreamCorruptedException"+                               , "StreamHandler"+                               , "StreamPrintService"+                               , "StreamPrintServiceFactory"+                               , "StreamResult"+                               , "StreamSource"+                               , "StreamTokenizer"+                               , "Streamable"+                               , "StreamableValue"+                               , "StrictMath"+                               , "String"+                               , "StringBuffer"+                               , "StringBufferInputStream"+                               , "StringCharacterIterator"+                               , "StringContent"+                               , "StringHolder"+                               , "StringIndexOutOfBoundsException"+                               , "StringNameHelper"+                               , "StringReader"+                               , "StringRefAddr"+                               , "StringSelection"+                               , "StringSeqHelper"+                               , "StringSeqHolder"+                               , "StringTokenizer"+                               , "StringValueHelper"+                               , "StringWriter"+                               , "Stroke"+                               , "Struct"+                               , "StructMember"+                               , "StructMemberHelper"+                               , "Stub"+                               , "StubDelegate"+                               , "StubNotFoundException"+                               , "Style"+                               , "StyleConstants"+                               , "StyleContext"+                               , "StyleSheet"+                               , "StyledDocument"+                               , "StyledEditorKit"+                               , "StyledTextAction"+                               , "Subject"+                               , "SubjectDomainCombiner"+                               , "Subset"+                               , "SupportedValuesAttribute"+                               , "SwingConstants"+                               , "SwingPropertyChangeSupport"+                               , "SwingUtilities"+                               , "SyncFailedException"+                               , "SyncMode"+                               , "SyncScopeHelper"+                               , "Synthesizer"+                               , "SysexMessage"+                               , "System"+                               , "SystemColor"+                               , "SystemException"+                               , "SystemFlavorMap"+                               , "TAG_ALTERNATE_IIOP_ADDRESS"+                               , "TAG_CODE_SETS"+                               , "TAG_INTERNET_IOP"+                               , "TAG_JAVA_CODEBASE"+                               , "TAG_MULTIPLE_COMPONENTS"+                               , "TAG_ORB_TYPE"+                               , "TAG_POLICIES"+                               , "TCKind"+                               , "THREAD_POLICY_ID"+                               , "TRANSACTION_REQUIRED"+                               , "TRANSACTION_ROLLEDBACK"+                               , "TRANSIENT"+                               , "TRANSPORT_RETRY"+                               , "TabExpander"+                               , "TabSet"+                               , "TabStop"+                               , "TabableView"+                               , "TabbedPaneUI"+                               , "TableCellEditor"+                               , "TableCellRenderer"+                               , "TableColumn"+                               , "TableColumnModel"+                               , "TableColumnModelEvent"+                               , "TableColumnModelListener"+                               , "TableHeaderBorder"+                               , "TableHeaderUI"+                               , "TableModel"+                               , "TableModelEvent"+                               , "TableModelListener"+                               , "TableUI"+                               , "TableView"+                               , "Tag"+                               , "TagElement"+                               , "TaggedComponent"+                               , "TaggedComponentHelper"+                               , "TaggedComponentHolder"+                               , "TaggedProfile"+                               , "TaggedProfileHelper"+                               , "TaggedProfileHolder"+                               , "TargetDataLine"+                               , "Templates"+                               , "TemplatesHandler"+                               , "Text"+                               , "TextAction"+                               , "TextArea"+                               , "TextAttribute"+                               , "TextComponent"+                               , "TextEvent"+                               , "TextField"+                               , "TextFieldBorder"+                               , "TextHitInfo"+                               , "TextInputCallback"+                               , "TextLayout"+                               , "TextListener"+                               , "TextMeasurer"+                               , "TextOutputCallback"+                               , "TextSyntax"+                               , "TextUI"+                               , "TexturePaint"+                               , "Thread"+                               , "ThreadDeath"+                               , "ThreadGroup"+                               , "ThreadLocal"+                               , "ThreadPolicy"+                               , "ThreadPolicyOperations"+                               , "ThreadPolicyValue"+                               , "Throwable"+                               , "Tie"+                               , "TileObserver"+                               , "Time"+                               , "TimeLimitExceededException"+                               , "TimeZone"+                               , "Timer"+                               , "TimerTask"+                               , "Timestamp"+                               , "TitledBorder"+                               , "TitledBorderUIResource"+                               , "ToggleButtonBorder"+                               , "ToggleButtonModel"+                               , "TooManyListenersException"+                               , "ToolBarBorder"+                               , "ToolBarUI"+                               , "ToolTipManager"+                               , "ToolTipUI"+                               , "Toolkit"+                               , "Track"+                               , "TransactionRequiredException"+                               , "TransactionRolledbackException"+                               , "TransactionService"+                               , "TransferHandler"+                               , "Transferable"+                               , "TransformAttribute"+                               , "Transformer"+                               , "TransformerConfigurationException"+                               , "TransformerException"+                               , "TransformerFactory"+                               , "TransformerFactoryConfigurationError"+                               , "TransformerHandler"+                               , "Transmitter"+                               , "Transparency"+                               , "TreeCellEditor"+                               , "TreeCellRenderer"+                               , "TreeControlIcon"+                               , "TreeExpansionEvent"+                               , "TreeExpansionListener"+                               , "TreeFolderIcon"+                               , "TreeLeafIcon"+                               , "TreeMap"+                               , "TreeModel"+                               , "TreeModelEvent"+                               , "TreeModelListener"+                               , "TreeNode"+                               , "TreePath"+                               , "TreeSelectionEvent"+                               , "TreeSelectionListener"+                               , "TreeSelectionModel"+                               , "TreeSet"+                               , "TreeUI"+                               , "TreeWillExpandListener"+                               , "TrustAnchor"+                               , "TrustManager"+                               , "TrustManagerFactory"+                               , "TrustManagerFactorySpi"+                               , "Type"+                               , "TypeCode"+                               , "TypeCodeHolder"+                               , "TypeMismatch"+                               , "TypeMismatchHelper"+                               , "Types"+                               , "UID"+                               , "UIDefaults"+                               , "UIManager"+                               , "UIResource"+                               , "ULongLongSeqHelper"+                               , "ULongLongSeqHolder"+                               , "ULongSeqHelper"+                               , "ULongSeqHolder"+                               , "UNKNOWN"+                               , "UNSUPPORTED_POLICY"+                               , "UNSUPPORTED_POLICY_VALUE"+                               , "URI"+                               , "URIException"+                               , "URIResolver"+                               , "URISyntax"+                               , "URISyntaxException"+                               , "URL"+                               , "URLClassLoader"+                               , "URLConnection"+                               , "URLDecoder"+                               , "URLEncoder"+                               , "URLStreamHandler"+                               , "URLStreamHandlerFactory"+                               , "URLStringHelper"+                               , "USER_EXCEPTION"+                               , "UShortSeqHelper"+                               , "UShortSeqHolder"+                               , "UTFDataFormatException"+                               , "UndeclaredThrowableException"+                               , "UnderlineAction"+                               , "UndoManager"+                               , "UndoableEdit"+                               , "UndoableEditEvent"+                               , "UndoableEditListener"+                               , "UndoableEditSupport"+                               , "UnexpectedException"+                               , "UnicastRemoteObject"+                               , "UnicodeBlock"+                               , "UnionMember"+                               , "UnionMemberHelper"+                               , "UnknownEncoding"+                               , "UnknownEncodingHelper"+                               , "UnknownError"+                               , "UnknownException"+                               , "UnknownGroupException"+                               , "UnknownHostException"+                               , "UnknownObjectException"+                               , "UnknownServiceException"+                               , "UnknownTag"+                               , "UnknownUserException"+                               , "UnknownUserExceptionHelper"+                               , "UnknownUserExceptionHolder"+                               , "UnmappableCharacterException"+                               , "UnmarshalException"+                               , "UnmodifiableSetException"+                               , "UnrecoverableKeyException"+                               , "Unreferenced"+                               , "UnresolvedAddressException"+                               , "UnresolvedPermission"+                               , "UnsatisfiedLinkError"+                               , "UnsolicitedNotification"+                               , "UnsolicitedNotificationEvent"+                               , "UnsolicitedNotificationListener"+                               , "UnsupportedAddressTypeException"+                               , "UnsupportedAudioFileException"+                               , "UnsupportedCallbackException"+                               , "UnsupportedCharsetException"+                               , "UnsupportedClassVersionError"+                               , "UnsupportedEncodingException"+                               , "UnsupportedFlavorException"+                               , "UnsupportedLookAndFeelException"+                               , "UnsupportedOperationException"+                               , "UserException"+                               , "Util"+                               , "UtilDelegate"+                               , "Utilities"+                               , "VMID"+                               , "VM_ABSTRACT"+                               , "VM_CUSTOM"+                               , "VM_NONE"+                               , "VM_TRUNCATABLE"+                               , "ValueBase"+                               , "ValueBaseHelper"+                               , "ValueBaseHolder"+                               , "ValueFactory"+                               , "ValueHandler"+                               , "ValueMember"+                               , "ValueMemberHelper"+                               , "VariableHeightLayoutCache"+                               , "Vector"+                               , "VerifyError"+                               , "VersionSpecHelper"+                               , "VetoableChangeListener"+                               , "VetoableChangeListenerProxy"+                               , "VetoableChangeSupport"+                               , "View"+                               , "ViewFactory"+                               , "ViewportLayout"+                               , "ViewportUI"+                               , "VirtualMachineError"+                               , "Visibility"+                               , "VisibilityHelper"+                               , "VoiceStatus"+                               , "Void"+                               , "VolatileImage"+                               , "WCharSeqHelper"+                               , "WCharSeqHolder"+                               , "WStringSeqHelper"+                               , "WStringSeqHolder"+                               , "WStringValueHelper"+                               , "WeakHashMap"+                               , "WeakReference"+                               , "Window"+                               , "WindowAdapter"+                               , "WindowConstants"+                               , "WindowEvent"+                               , "WindowFocusListener"+                               , "WindowListener"+                               , "WindowStateListener"+                               , "WrappedPlainView"+                               , "WritableByteChannel"+                               , "WritableRaster"+                               , "WritableRenderedImage"+                               , "WriteAbortedException"+                               , "Writer"+                               , "WrongAdapter"+                               , "WrongAdapterHelper"+                               , "WrongPolicy"+                               , "WrongPolicyHelper"+                               , "WrongTransaction"+                               , "WrongTransactionHelper"+                               , "WrongTransactionHolder"+                               , "X500Principal"+                               , "X500PrivateCredential"+                               , "X509CRL"+                               , "X509CRLEntry"+                               , "X509CRLSelector"+                               , "X509CertSelector"+                               , "X509Certificate"+                               , "X509EncodedKeySpec"+                               , "X509Extension"+                               , "X509KeyManager"+                               , "X509TrustManager"+                               , "XAConnection"+                               , "XADataSource"+                               , "XAException"+                               , "XAResource"+                               , "XMLDecoder"+                               , "XMLEncoder"+                               , "XMLFilter"+                               , "XMLFilterImpl"+                               , "XMLFormatter"+                               , "XMLReader"+                               , "XMLReaderAdapter"+                               , "XMLReaderFactory"+                               , "Xid"+                               , "ZipEntry"+                               , "ZipException"+                               , "ZipFile"+                               , "ZipInputStream"+                               , "ZipOutputStream"+                               , "ZoneView"+                               , "_BindingIteratorImplBase"+                               , "_BindingIteratorStub"+                               , "_DynAnyFactoryStub"+                               , "_DynAnyStub"+                               , "_DynArrayStub"+                               , "_DynEnumStub"+                               , "_DynFixedStub"+                               , "_DynSequenceStub"+                               , "_DynStructStub"+                               , "_DynUnionStub"+                               , "_DynValueStub"+                               , "_IDLTypeStub"+                               , "_NamingContextExtStub"+                               , "_NamingContextImplBase"+                               , "_NamingContextStub"+                               , "_PolicyStub"+                               , "_Remote_Stub"+                               , "_ServantActivatorStub"+                               , "_ServantLocatorStub"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren =+                          [ Rule+                              { rMatcher = AnyChar "fF"+                              , rAttribute = FloatTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren =+                          [ Rule+                              { rMatcher = StringDetect "ULL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LUL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LLU"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "UL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LU"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "U"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "L"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "//\\s*BEGIN.*$"+                              , reCompiled = Just (compileRegex False "//\\s*BEGIN.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "//\\s*END.*$"+                              , reCompiled = Just (compileRegex False "//\\s*END.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Java String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "!%&()+,-<=>?[]^{|}~"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Java Single-Line Comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Java Multi-Line Comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Jsp Single Quoted Custom Tag Value"+          , Context+              { cName = "Jsp Single Quoted Custom Tag Value"+              , cSyntax = "JSP"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<%--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%(!|=)?"+                              , reCompiled = Just (compileRegex False "<%(!|=)?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Scriptlet" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Expression" ) ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Jsp Single Quoted Param Value"+          , Context+              { cName = "Jsp Single Quoted Param Value"+              , cSyntax = "JSP"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<%--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%(!|=)?"+                              , reCompiled = Just (compileRegex False "<%(!|=)?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Scriptlet" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Expression" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Jsp Standard Directive"+          , Context+              { cName = "Jsp Standard Directive"+              , cSyntax = "JSP"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '%' '>'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*=\\s*"+                              , reCompiled = Just (compileRegex False "\\s*=\\s*")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "JSP" , "Jsp Standard Directive Value" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<%--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%(!|=)?"+                              , reCompiled = Just (compileRegex False "<%(!|=)?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Scriptlet" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Expression" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\s*\\/?\\s*\\$?\\w*:\\$?\\w*"+                              , reCompiled =+                                  Just (compileRegex False "<\\s*\\/?\\s*\\$?\\w*:\\$?\\w*")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Custom Tag" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Jsp Standard Directive Value"+          , Context+              { cName = "Jsp Standard Directive Value"+              , cSyntax = "JSP"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<%--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%(!|=)?"+                              , reCompiled = Just (compileRegex False "<%(!|=)?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Scriptlet" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Expression" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "JSP" , "Jsp Double Quoted Param Value" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "JSP" , "Jsp Single Quoted Param Value" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '%' '>'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Jsp Xml Directive"+          , Context+              { cName = "Jsp Xml Directive"+              , cSyntax = "JSP"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\/?\\s*>"+                              , reCompiled = Just (compileRegex False "\\s*\\/?\\s*>")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*=\\s*"+                              , reCompiled = Just (compileRegex False "\\s*=\\s*")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Xml Directive Value" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<%--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%(!|=)?"+                              , reCompiled = Just (compileRegex False "<%(!|=)?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Scriptlet" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Expression" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Jsp Xml Directive Value"+          , Context+              { cName = "Jsp Xml Directive Value"+              , cSyntax = "JSP"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<%--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%(!|=)?"+                              , reCompiled = Just (compileRegex False "<%(!|=)?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Scriptlet" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Expression" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "JSP" , "Jsp Double Quoted Param Value" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "JSP" , "Jsp Single Quoted Param Value" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\/?\\s*>"+                              , reCompiled = Just (compileRegex False "\\s*\\/?\\s*>")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "JSP"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%@\\s*[a-zA-Z0-9_\\.]*"+                              , reCompiled = Just (compileRegex False "<%@\\s*[a-zA-Z0-9_\\.]*")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Standard Directive" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\s*jsp:(declaration|expression|scriptlet)\\s*>"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False "<\\s*jsp:(declaration|expression|scriptlet)\\s*>")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Scriptlet" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\s*\\/?s*jsp:[a-zA-Z0-9_\\.]*"+                              , reCompiled =+                                  Just (compileRegex False "<\\s*\\/?s*jsp:[a-zA-Z0-9_\\.]*")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Xml Directive" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<%--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%(!|=)?"+                              , reCompiled = Just (compileRegex False "<%(!|=)?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Scriptlet" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Html Comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Expression" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\s*\\/?\\s*\\$?[a-zA-Z0-9_]*:\\$?[a-zA-Z0-9_]*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False "<\\s*\\/?\\s*\\$?[a-zA-Z0-9_]*:\\$?[a-zA-Z0-9_]*")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Jsp Custom Tag" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<![CDATA["+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "]]>"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\s*\\/?\\s*[a-zA-Z0-9_]*"+                              , reCompiled =+                                  Just (compileRegex False "<\\s*\\/?\\s*[a-zA-Z0-9_]*")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "JSP" , "Html Attribute" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Rob Martin (rob@gamepimp.com)"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions = [ "*.jsp" , "*.JSP" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Julia.hs view
@@ -0,0 +1,1035 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Julia (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Julia"+  , sFilename = "julia.xml"+  , sShortname = "Julia"+  , sContexts =+      fromList+        [ ( "1-comment"+          , Context+              { cName = "1-comment"+              , cSyntax = "Julia"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Julia"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "_adjoint"+          , Context+              { cName = "_adjoint"+              , cSyntax = "Julia"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'+"+                              , reCompiled = Just (compileRegex True "'+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "_normal"+          , Context+              { cName = "_normal"+              , cSyntax = "Julia"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "begin"+                               , "do"+                               , "for"+                               , "function"+                               , "if"+                               , "let"+                               , "quote"+                               , "try"+                               , "type"+                               , "while"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "catch" , "else" , "elseif" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "end" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "#BEGIN"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Julia" , "region_marker" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "#END"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Julia" , "region_marker" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "abstract"+                               , "bitstype"+                               , "break"+                               , "ccall"+                               , "const"+                               , "continue"+                               , "export"+                               , "global"+                               , "import"+                               , "in"+                               , "local"+                               , "macro"+                               , "module"+                               , "return"+                               , "typealias"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ASCIIString"+                               , "AbstractArray"+                               , "AbstractMatrix"+                               , "AbstractVector"+                               , "Any"+                               , "Array"+                               , "Associative"+                               , "Bool"+                               , "ByteString"+                               , "Char"+                               , "Complex"+                               , "Complex128"+                               , "Complex64"+                               , "ComplexPair"+                               , "DArray"+                               , "Dict"+                               , "Exception"+                               , "Expr"+                               , "Float"+                               , "Float32"+                               , "Float64"+                               , "Function"+                               , "IO"+                               , "IOStream"+                               , "Int"+                               , "Int16"+                               , "Int32"+                               , "Int64"+                               , "Int8"+                               , "IntSet"+                               , "Integer"+                               , "Matrix"+                               , "NTuple"+                               , "None"+                               , "Nothing"+                               , "Number"+                               , "ObjectIdDict"+                               , "Ptr"+                               , "Range"+                               , "Range1"+                               , "Ranges"+                               , "Rational"+                               , "Real"+                               , "Regex"+                               , "RegexMatch"+                               , "Set"+                               , "Signed"+                               , "StridedArray"+                               , "StridedMatrix"+                               , "StridedVecOrMat"+                               , "StridedVector"+                               , "String"+                               , "SubArray"+                               , "SubString"+                               , "Symbol"+                               , "Task"+                               , "Tuple"+                               , "Type"+                               , "UTF8String"+                               , "Uint"+                               , "Uint16"+                               , "Uint32"+                               , "Uint64"+                               , "Uint8"+                               , "Union"+                               , "Unsigned"+                               , "VecOrMat"+                               , "Vector"+                               , "Void"+                               , "WeakRef"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Julia" , "1-comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Julia" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "..."+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "::"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect ">>>"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect ">>"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<<"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "=="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "!="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect ">="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "&&"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "||"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect ".*"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect ".^"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "./"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect ".'"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "+="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "-="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "*="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "/="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "&="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "|="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "$="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect ">>>="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect ">>="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<<="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z]\\w*(?=')"+                              , reCompiled = Just (compileRegex True "[a-zA-Z]\\w*(?=')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Julia" , "_adjoint" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\d+(\\.\\d+)?|\\.\\d+)([eE][+-]?\\d+)?(im)?(?=')"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(\\d+(\\.\\d+)?|\\.\\d+)([eE][+-]?\\d+)?(im)?(?=')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Julia" , "_adjoint" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\)\\]}](?=')"+                              , reCompiled = Just (compileRegex True "[\\)\\]}](?=')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Julia" , "_adjoint" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.'(?=')"+                              , reCompiled = Just (compileRegex True "\\.'(?=')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Julia" , "_adjoint" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'[^']*(''[^']*)*'(?=[^']|$)"+                              , reCompiled =+                                  Just (compileRegex True "'[^']*(''[^']*)*'(?=[^']|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'[^']*(''[^']*)*"+                              , reCompiled = Just (compileRegex True "'[^']*(''[^']*)*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "0x[0-9a-fA-F]+(im)?"+                              , reCompiled = Just (compileRegex True "0x[0-9a-fA-F]+(im)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\d+(\\.\\d+)?|\\.\\d+)([eE][+-]?\\d+)?(im)?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(\\d+(\\.\\d+)?|\\.\\d+)([eE][+-]?\\d+)?(im)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "()[]{}"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "*+-/\\&|<>~$!^=,;:@"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "curly"+          , Context+              { cName = "curly"+              , cSyntax = "Julia"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "nested"+          , Context+              { cName = "nested"+              , cSyntax = "Julia"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "region_marker"+          , Context+              { cName = "region_marker"+              , cSyntax = "Julia"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Julia" , "1-comment" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "squared"+          , Context+              { cName = "squared"+              , cSyntax = "Julia"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = ""+  , sVersion = "1"+  , sLicense = "MIT"+  , sExtensions = [ "*.jl" ]+  , sStartingContext = "_normal"+  }
+ src/Skylighting/Syntax/Kotlin.hs view
@@ -0,0 +1,1876 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Kotlin (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Kotlin"+  , sFilename = "kotlin.xml"+  , sShortname = "Kotlin"+  , sContexts =+      fromList+        [ ( "Char"+          , Context+              { cName = "Char"+              , cSyntax = "Kotlin"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\u[0-9a-fA-F]{4}"+                              , reCompiled = Just (compileRegex True "\\\\u[0-9a-fA-F]{4}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CommentMultiline"+          , Context+              { cName = "CommentMultiline"+              , cSyntax = "Kotlin"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "TODO"+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CommentSingleLine"+          , Context+              { cName = "CommentSingleLine"+              , cSyntax = "Kotlin"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "TODO"+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Expression"+          , Context+              { cName = "Expression"+              , cSyntax = "Kotlin"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "ExpressionInner" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "ExpressionInner" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\w+"+                              , reCompiled = Just (compileRegex True "<\\w+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "TypeParameters" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "Char" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "\"\"\""+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "MultiLineDoubleString" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "CommentSingleLine" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "CommentMultiline" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ExpressionInner"+          , Context+              { cName = "ExpressionInner"+              , cSyntax = "Kotlin"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "ExpressionInner" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "ExpressionInner" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\w+"+                              , reCompiled = Just (compileRegex True "<\\w+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "TypeParameters" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "Char" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "\"\"\""+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "MultiLineDoubleString" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "CommentSingleLine" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "CommentMultiline" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FunctionDeclaration"+          , Context+              { cName = "FunctionDeclaration"+              , cSyntax = "Kotlin"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "as"+                               , "by"+                               , "class"+                               , "companion"+                               , "constructor"+                               , "crossinline"+                               , "data"+                               , "enum"+                               , "final"+                               , "fun"+                               , "get"+                               , "import"+                               , "in"+                               , "infix"+                               , "inline"+                               , "interface"+                               , "internal"+                               , "is"+                               , "object"+                               , "open"+                               , "operator"+                               , "out"+                               , "override"+                               , "package"+                               , "private"+                               , "protected"+                               , "public"+                               , "reified"+                               , "return"+                               , "sealed"+                               , "set"+                               , "tailrec"+                               , "throw"+                               , "typealias"+                               , "typeof"+                               , "val"+                               , "var"+                               , "vararg"+                               , "where"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '.'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "Parameters" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "TypeParameters" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "TypeName" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "{="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[_\\w][_\\w\\d]*"+                              , reCompiled = Just (compileRegex True "[_\\w][_\\w\\d]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FunctionType"+          , Context+              { cName = "FunctionType"+              , cSyntax = "Kotlin"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[_\\w][_\\w\\d]*[?]?"+                              , reCompiled = Just (compileRegex True "[_\\w][_\\w\\d]*[?]?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "->"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect ","+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Imports"+          , Context+              { cName = "Imports"+              , cSyntax = "Kotlin"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "as"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "TypeName" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[_\\w][_\\w\\d]*(\\.[_\\w][_\\w\\d]*)*(\\.\\*)?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\b[_\\w][_\\w\\d]*(\\.[_\\w][_\\w\\d]*)*(\\.\\*)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ImportTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MultiLineDoubleString"+          , Context+              { cName = "MultiLineDoubleString"+              , cSyntax = "Kotlin"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "\"\"\""+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Kotlin"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(package|import)\\b"+                              , reCompiled = Just (compileRegex True "\\b(package|import)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "Imports" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bfun\\b"+                              , reCompiled = Just (compileRegex True "\\bfun\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "FunctionDeclaration" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(object|class|interface)\\b"+                              , reCompiled =+                                  Just (compileRegex True "\\b(object|class|interface)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "TypeDeclaration" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(val|var)\\b"+                              , reCompiled = Just (compileRegex True "\\b(val|var)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "VariableDeclaration" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "false" , "null" , "super" , "this" , "true" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "as"+                               , "by"+                               , "class"+                               , "companion"+                               , "constructor"+                               , "crossinline"+                               , "data"+                               , "enum"+                               , "final"+                               , "fun"+                               , "get"+                               , "import"+                               , "in"+                               , "infix"+                               , "inline"+                               , "interface"+                               , "internal"+                               , "is"+                               , "object"+                               , "open"+                               , "operator"+                               , "out"+                               , "override"+                               , "package"+                               , "private"+                               , "protected"+                               , "public"+                               , "reified"+                               , "return"+                               , "sealed"+                               , "set"+                               , "tailrec"+                               , "throw"+                               , "typealias"+                               , "typeof"+                               , "val"+                               , "var"+                               , "vararg"+                               , "where"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "break"+                               , "catch"+                               , "continue"+                               , "do"+                               , "else"+                               , "finally"+                               , "for"+                               , "if"+                               , "try"+                               , "when"+                               , "while"+                               , "yield"+                               ])+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Boolean"+                               , "Byte"+                               , "Char"+                               , "Double"+                               , "Float"+                               , "Int"+                               , "Long"+                               , "Nothing"+                               , "Short"+                               , "String"+                               , "Unit"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "\"\"\""+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "MultiLineDoubleString" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "Char" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "CommentSingleLine" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "CommentMultiline" ) ]+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren =+                          [ Rule+                              { rMatcher = AnyChar "fF"+                              , rAttribute = FloatTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = True+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren =+                          [ Rule+                              { rMatcher = StringDetect "L"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@[_\\w][_\\w\\d]*"+                              , reCompiled = Just (compileRegex True "@[_\\w][_\\w\\d]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "TODO\\s*\\([^)]*\\)"+                              , reCompiled = Just (compileRegex True "TODO\\s*\\([^)]*\\)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '!'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "CommentSingleLine" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Parameters"+          , Context+              { cName = "Parameters"+              , cSyntax = "Kotlin"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "as"+                               , "by"+                               , "class"+                               , "companion"+                               , "constructor"+                               , "crossinline"+                               , "data"+                               , "enum"+                               , "final"+                               , "fun"+                               , "get"+                               , "import"+                               , "in"+                               , "infix"+                               , "inline"+                               , "interface"+                               , "internal"+                               , "is"+                               , "object"+                               , "open"+                               , "operator"+                               , "out"+                               , "override"+                               , "package"+                               , "private"+                               , "protected"+                               , "public"+                               , "reified"+                               , "return"+                               , "sealed"+                               , "set"+                               , "tailrec"+                               , "throw"+                               , "typealias"+                               , "typeof"+                               , "val"+                               , "var"+                               , "vararg"+                               , "where"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "TypeName" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "Expression" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[_\\w][_\\w\\d]*"+                              , reCompiled = Just (compileRegex True "[_\\w][_\\w\\d]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Kotlin"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\u[0-9a-fA-F]{4}"+                              , reCompiled = Just (compileRegex True "\\\\u[0-9a-fA-F]{4}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SuperTypes"+          , Context+              { cName = "SuperTypes"+              , cSyntax = "Kotlin"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "as"+                               , "by"+                               , "class"+                               , "companion"+                               , "constructor"+                               , "crossinline"+                               , "data"+                               , "enum"+                               , "final"+                               , "fun"+                               , "get"+                               , "import"+                               , "in"+                               , "infix"+                               , "inline"+                               , "interface"+                               , "internal"+                               , "is"+                               , "object"+                               , "open"+                               , "operator"+                               , "out"+                               , "override"+                               , "package"+                               , "private"+                               , "protected"+                               , "public"+                               , "reified"+                               , "return"+                               , "sealed"+                               , "set"+                               , "tailrec"+                               , "throw"+                               , "typealias"+                               , "typeof"+                               , "val"+                               , "var"+                               , "vararg"+                               , "where"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "Parameters" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "TypeParameters" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[_\\w][_\\w\\d]*"+                              , reCompiled = Just (compileRegex True "[_\\w][_\\w\\d]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "TypeDeclaration"+          , Context+              { cName = "TypeDeclaration"+              , cSyntax = "Kotlin"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "as"+                               , "by"+                               , "class"+                               , "companion"+                               , "constructor"+                               , "crossinline"+                               , "data"+                               , "enum"+                               , "final"+                               , "fun"+                               , "get"+                               , "import"+                               , "in"+                               , "infix"+                               , "inline"+                               , "interface"+                               , "internal"+                               , "is"+                               , "object"+                               , "open"+                               , "operator"+                               , "out"+                               , "override"+                               , "package"+                               , "private"+                               , "protected"+                               , "public"+                               , "reified"+                               , "return"+                               , "sealed"+                               , "set"+                               , "tailrec"+                               , "throw"+                               , "typealias"+                               , "typeof"+                               , "val"+                               , "var"+                               , "vararg"+                               , "where"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "TypeParameters" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "Parameters" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "SuperTypes" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "TypeName"+          , Context+              { cName = "TypeName"+              , cSyntax = "Kotlin"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '*'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "FunctionType" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "->"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[_\\w][_\\w\\d]*[?]?"+                              , reCompiled = Just (compileRegex True "[_\\w][_\\w\\d]*[?]?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "TypeParameters"+          , Context+              { cName = "TypeParameters"+              , cSyntax = "Kotlin"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "as"+                               , "by"+                               , "class"+                               , "companion"+                               , "constructor"+                               , "crossinline"+                               , "data"+                               , "enum"+                               , "final"+                               , "fun"+                               , "get"+                               , "import"+                               , "in"+                               , "infix"+                               , "inline"+                               , "interface"+                               , "internal"+                               , "is"+                               , "object"+                               , "open"+                               , "operator"+                               , "out"+                               , "override"+                               , "package"+                               , "private"+                               , "protected"+                               , "public"+                               , "reified"+                               , "return"+                               , "sealed"+                               , "set"+                               , "tailrec"+                               , "throw"+                               , "typealias"+                               , "typeof"+                               , "val"+                               , "var"+                               , "vararg"+                               , "where"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "TypeName" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '*'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Kotlin" , "TypeParameters" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[_\\w][_\\w\\d]*[?]?"+                              , reCompiled = Just (compileRegex True "[_\\w][_\\w\\d]*[?]?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "VariableDeclaration"+          , Context+              { cName = "VariableDeclaration"+              , cSyntax = "Kotlin"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "symbols"+          , Context+              { cName = "symbols"+              , cSyntax = "Kotlin"+              , cRules =+                  [ Rule+                      { rMatcher = AnyChar ":!%&+,-/.*<=>?[]|~^;"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Sergey Mashkov (sergey.mashkov@jetbrains.com)"+  , sVersion = "2"+  , sLicense = "LGPLv2+"+  , sExtensions = [ "*.kt" , "*.kts" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Latex.hs view
@@ -0,0 +1,5369 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Latex (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex++syntax :: Syntax+syntax = Syntax+  { sName = "LaTeX"+  , sFilename = "latex.xml"+  , sShortname = "Latex"+  , sContexts =+      fromList+        [ ( "BeginEnvironment"+          , Context+              { cName = "BeginEnvironment"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "lstlisting"+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "ListingsEnvParam" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "minted"+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MintedEnvParam" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "((B|L)?Verbatim)"+                              , reCompiled = Just (compileRegex True "((B|L)?Verbatim)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "VerbatimEnvParam" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(verbatim|boxedverbatim)"+                              , reCompiled = Just (compileRegex True "(verbatim|boxedverbatim)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "VerbatimEnv" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "comment"+                              , reCompiled = Just (compileRegex True "comment")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "CommentEnv" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(alignat|xalignat|xxalignat)"+                              , reCompiled =+                                  Just (compileRegex True "(alignat|xalignat|xxalignat)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathEnvParam" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(equation|displaymath|eqnarray|subeqnarray|math|multline|gather|align|flalign|IEEEeqnarray|IEEEeqnarraybox|smallmatrix|pmatrix|bmatrix|Bmatrix|vmatrix|Vmatrix|cases)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(equation|displaymath|eqnarray|subeqnarray|math|multline|gather|align|flalign|IEEEeqnarray|IEEEeqnarraybox|smallmatrix|pmatrix|bmatrix|Bmatrix|vmatrix|Vmatrix|cases)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathEnv" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(tabularx|tabular|supertabular|mpsupertabular|xtabular|mpxtabular|longtable)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(tabularx|tabular|supertabular|mpsupertabular|xtabular|mpxtabular|longtable)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "TabEnv" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z]"+                              , reCompiled = Just (compileRegex True "[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "LatexEnv" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+"+                              , reCompiled = Just (compileRegex True "\\s+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^a-zA-Z\\xd7]"+                              , reCompiled = Just (compileRegex True "[^a-zA-Z\\xd7]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = ExtensionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "BlockComment"+          , Context+              { cName = "BlockComment"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\end(?=\\s*\\{comment\\*?\\})"+                              , reCompiled =+                                  Just (compileRegex True "\\\\end(?=\\s*\\{comment\\*?\\})")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "CommFindEnd" ) ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Column Separator"+          , Context+              { cName = "Column Separator"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Column Separator" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CharTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CommFindEnd"+          , Context+              { cName = "CommFindEnd"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\{"+                              , reCompiled = Just (compileRegex True "\\s*\\{")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "comment\\*?"+                              , reCompiled = Just (compileRegex True "comment\\*?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "CommandParameter"+          , Context+              { cName = "CommandParameter"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "CommandParameter" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CommandParameterStart"+          , Context+              { cName = "CommandParameterStart"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "CommandParameter" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(FIXME|TODO):?"+                              , reCompiled = Just (compileRegex True "(FIXME|TODO):?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "\\KileResetHL"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Normal Text" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "\\KateResetHL"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Normal Text" ) ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CommentEnv"+          , Context+              { cName = "CommentEnv"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "BlockComment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z]"+                              , reCompiled = Just (compileRegex True "[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LaTeX" , "EnvCommon" )+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ExtensionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop , Pop , Pop ]+              , cDynamic = False+              }+          )+        , ( "ContrSeq"+          , Context+              { cName = "ContrSeq"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "verb*"+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Verb" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(Verb|verb)(?=[^a-zA-Z])"+                              , reCompiled = Just (compileRegex True "(Verb|verb)(?=[^a-zA-Z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Verb" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(lstinline)(?=[^a-zA-Z])"+                              , reCompiled = Just (compileRegex True "(lstinline)(?=[^a-zA-Z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Lstinline" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "mint(?=[^a-zA-Z])"+                              , reCompiled = Just (compileRegex True "mint(?=[^a-zA-Z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MintParam" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z@]+(\\+?|\\*{0,3})"+                              , reCompiled = Just (compileRegex True "[a-zA-Z@]+(\\+?|\\*{0,3})")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^a-zA-Z]"+                              , reCompiled = Just (compileRegex True "[^a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DefCommand"+          , Context+              { cName = "DefCommand"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\\\[a-zA-Z]+[^\\{]*\\{"+                              , reCompiled =+                                  Just (compileRegex True "\\s*\\\\[a-zA-Z]+[^\\{]*\\{")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "CommandParameterStart" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "EndEnvironment"+          , Context+              { cName = "EndEnvironment"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z]"+                              , reCompiled = Just (compileRegex True "[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "EndLatexEnv" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+"+                              , reCompiled = Just (compileRegex True "\\s+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^a-zA-Z]"+                              , reCompiled = Just (compileRegex True "[^a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = ExtensionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "EndLatexEnv"+          , Context+              { cName = "EndLatexEnv"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z]+(\\*)?"+                              , reCompiled = Just (compileRegex True "[a-zA-Z]+(\\*)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+"+                              , reCompiled = Just (compileRegex True "\\s+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z]"+                              , reCompiled = Just (compileRegex True "[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = ExtensionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "EnvCommon"+          , Context+              { cName = "EnvCommon"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\*(?=\\})"+                              , reCompiled = Just (compileRegex True "\\*(?=\\})")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\*[^\\}]*"+                              , reCompiled = Just (compileRegex True "\\*[^\\}]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^a-zA-Z\\xd7][^\\}]*"+                              , reCompiled = Just (compileRegex True "[^a-zA-Z\\xd7][^\\}]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = ExtensionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FancyLabel"+          , Context+              { cName = "FancyLabel"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\{\\s*"+                              , reCompiled = Just (compileRegex True "\\s*\\{\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "FancyLabelParameter" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\[\\s*"+                              , reCompiled = Just (compileRegex True "\\s*\\[\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "FancyLabelOption" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\(\\s*"+                              , reCompiled = Just (compileRegex True "\\s*\\(\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "FancyLabelRoundBrackets" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "FancyLabelOption"+          , Context+              { cName = "FancyLabelOption"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "\\("+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathMode" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "ContrSeq" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathMode" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\]\\s*"+                              , reCompiled = Just (compileRegex True "\\s*\\]\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FancyLabelParameter"+          , Context+              { cName = "FancyLabelParameter"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "\\("+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathMode" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "ContrSeq" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathMode" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\}\\s*"+                              , reCompiled = Just (compileRegex True "\\s*\\}\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = ExtensionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FancyLabelRoundBrackets"+          , Context+              { cName = "FancyLabelRoundBrackets"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "\\("+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathMode" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "ContrSeq" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathMode" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\)\\s*"+                              , reCompiled = Just (compileRegex True "\\s*\\)\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindBeginEnvironment"+          , Context+              { cName = "FindBeginEnvironment"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "BeginEnvironment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindEndEnvironment"+          , Context+              { cName = "FindEndEnvironment"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "EndEnvironment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Footnoting"+          , Context+              { cName = "Footnoting"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[[^\\]]*\\]"+                              , reCompiled = Just (compileRegex True "\\[[^\\]]*\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ' '+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "FootnotingInside" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "FootnotingInside"+          , Context+              { cName = "FootnotingInside"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "FootnotingInside" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "\\("+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "FootnotingMathMode" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "FootnotingMathMode" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LaTeX" , "Normal Text" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FootnotingMathMode"+          , Context+              { cName = "FootnotingMathMode"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "$$"+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ')'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ']'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LaTeX" , "MathMode" )+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "HighlightningBeginC++"+          , Context+              { cName = "HighlightningBeginC++"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ".*(\\}|\\])"+                              , reCompiled = Just (compileRegex True ".*(\\}|\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "HighlightningC++" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "HighlightningBeginPython"+          , Context+              { cName = "HighlightningBeginPython"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ".*(\\}|\\])"+                              , reCompiled = Just (compileRegex True ".*(\\}|\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "HighlightningPython" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "HighlightningC++"+          , Context+              { cName = "HighlightningC++"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "LaTeX" , "HighlightningCommon" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "C++" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = True+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "HighlightningCommon"+          , Context+              { cName = "HighlightningCommon"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\end\\s*\\{(lstlisting|minted)\\*?\\}"+                              , reCompiled =+                                  Just+                                    (compileRegex True "\\\\end\\s*\\{(lstlisting|minted)\\*?\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop , Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "HighlightningPython"+          , Context+              { cName = "HighlightningPython"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "LaTeX" , "HighlightningCommon" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "HighlightningSelector"+          , Context+              { cName = "HighlightningSelector"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "C++"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "HighlightningBeginC++" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "Python"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "LaTeX" , "HighlightningBeginPython" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ".*(?=\\}|\\])"+                              , reCompiled = Just (compileRegex True ".*(?=\\}|\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Label"+          , Context+              { cName = "Label"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\{\\s*"+                              , reCompiled = Just (compileRegex True "\\s*\\{\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "LabelParameter" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\[\\s*"+                              , reCompiled = Just (compileRegex True "\\s*\\[\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "LabelOption" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^\\[\\{]+"+                              , reCompiled = Just (compileRegex True "[^\\[\\{]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "LabelOption"+          , Context+              { cName = "LabelOption"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "\\("+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathMode" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "ContrSeq" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathMode" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\]\\s*"+                              , reCompiled = Just (compileRegex True "\\s*\\]\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "LabelParameter"+          , Context+              { cName = "LabelParameter"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\}\\s*"+                              , reCompiled = Just (compileRegex True "\\s*\\}\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = ExtensionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "LatexEnv"+          , Context+              { cName = "LatexEnv"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z]+"+                              , reCompiled = Just (compileRegex True "[a-zA-Z]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+"+                              , reCompiled = Just (compileRegex True "\\s+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LaTeX" , "EnvCommon" )+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ExtensionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ListingsEnvParam"+          , Context+              { cName = "ListingsEnvParam"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '}' '['+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "language\\s*=\\s*(?=[^,]+)"+                              , reCompiled =+                                  Just (compileRegex True "language\\s*=\\s*(?=[^,]+)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "HighlightningSelector" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Verbatim" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Verbatim" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Push ( "LaTeX" , "Verbatim" ) ]+              , cDynamic = False+              }+          )+        , ( "Lstinline"+          , Context+              { cName = "Lstinline"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\[\\s*"+                              , reCompiled = Just (compileRegex True "\\s*\\[\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "FancyLabelOption" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\{\\s*"+                              , reCompiled = Just (compileRegex True "\\s*\\{\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "LstinlineParameter" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(.)"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "LstinlineEnd" ) ]+                      }+                  ]+              , cAttribute = VerbatimStringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "LstinlineEnd"+          , Context+              { cName = "LstinlineEnd"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "%1"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^%1\\xd7]*"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = VerbatimStringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "LstinlineParameter"+          , Context+              { cName = "LstinlineParameter"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\}\\s*"+                              , reCompiled = Just (compileRegex True "\\s*\\}\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = VerbatimStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MathContrSeq"+          , Context+              { cName = "MathContrSeq"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z]+\\*?"+                              , reCompiled = Just (compileRegex True "[a-zA-Z]+\\*?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^a-zA-Z]"+                              , reCompiled = Just (compileRegex True "[^a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = SpecialCharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MathEnv"+          , Context+              { cName = "MathEnv"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathModeEnv" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z]"+                              , reCompiled = Just (compileRegex True "[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LaTeX" , "EnvCommon" )+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ExtensionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MathEnvParam"+          , Context+              { cName = "MathEnvParam"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\}\\{[^\\}]*\\}"+                              , reCompiled = Just (compileRegex True "\\}\\{[^\\}]*\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathModeEnv" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathModeEnv" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z]"+                              , reCompiled = Just (compileRegex True "[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LaTeX" , "EnvCommon" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MathFindEnd"+          , Context+              { cName = "MathFindEnd"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\{"+                              , reCompiled = Just (compileRegex True "\\s*\\{")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(equation|displaymath|eqnarray|subeqnarray|math|multline|gather|align|flalign|alignat|xalignat|xxalignat|IEEEeqnarray|IEEEeqnarraybox|smallmatrix|pmatrix|bmatrix|Bmatrix|vmatrix|Vmatrix|cases)\\*?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(equation|displaymath|eqnarray|subeqnarray|math|multline|gather|align|flalign|alignat|xalignat|xxalignat|IEEEeqnarray|IEEEeqnarraybox|smallmatrix|pmatrix|bmatrix|Bmatrix|vmatrix|Vmatrix|cases)\\*?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "MathMode"+          , Context+              { cName = "MathMode"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "$$"+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ')'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ']'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LaTeX" , "MathModeCommon" )+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MathModeCommon"+          , Context+              { cName = "MathModeCommon"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(begin|end)\\s*\\{(equation|displaymath|eqnarray|subeqnarray|math|multline|gather|align|flalign|alignat|xalignat|xxalignat|IEEEeqnarray)\\*?\\}"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(begin|end)\\s*\\{(equation|displaymath|eqnarray|subeqnarray|math|multline|gather|align|flalign|alignat|xalignat|xxalignat|IEEEeqnarray)\\*?\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\begin(?=[^a-zA-Z])"+                              , reCompiled = Just (compileRegex True "\\\\begin(?=[^a-zA-Z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\end(?=[^a-zA-Z])"+                              , reCompiled = Just (compileRegex True "\\\\end(?=[^a-zA-Z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(text|intertext|mbox)\\s*(?=\\{)"+                              , reCompiled =+                                  Just (compileRegex True "\\\\(text|intertext|mbox)\\s*(?=\\{)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathModeText" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathContrSeq" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%\\s*BEGIN.*$"+                              , reCompiled = Just (compileRegex True "%\\s*BEGIN.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%\\s*END.*$"+                              , reCompiled = Just (compileRegex True "%\\s*END.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MathModeDisplay"+          , Context+              { cName = "MathModeDisplay"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "$$"+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ']'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ')'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LaTeX" , "MathModeCommon" )+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MathModeEnsure"+          , Context+              { cName = "MathModeEnsure"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathModeEnsure" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LaTeX" , "MathModeCommon" )+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MathModeEnv"+          , Context+              { cName = "MathModeEnv"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\begin(?=[^a-zA-Z])"+                              , reCompiled = Just (compileRegex True "\\\\begin(?=[^a-zA-Z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "FindBeginEnvironment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\end(?=[^a-zA-Z])"+                              , reCompiled = Just (compileRegex True "\\\\end(?=[^a-zA-Z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathFindEnd" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "\\("+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "\\["+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "\\)"+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "\\]"+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(text|intertext|mbox)\\s*(?=\\{)"+                              , reCompiled =+                                  Just (compileRegex True "\\\\(text|intertext|mbox)\\s*(?=\\{)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathModeText" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathContrSeq" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "$$"+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%\\s*BEGIN.*$"+                              , reCompiled = Just (compileRegex True "%\\s*BEGIN.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%\\s*END.*$"+                              , reCompiled = Just (compileRegex True "%\\s*END.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MathModeEquation"+          , Context+              { cName = "MathModeEquation"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' ']'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "$$"+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ')'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LaTeX" , "MathModeCommon" )+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MathModeText"+          , Context+              { cName = "MathModeText"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "LaTeX" , "MathModeTextParameterStart" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MathModeTextParameter"+          , Context+              { cName = "MathModeTextParameter"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathModeTextParameter" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MathModeTextParameterStart"+          , Context+              { cName = "MathModeTextParameterStart"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$.*\\$"+                              , reCompiled = Just (compileRegex True "\\$.*\\$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathModeTextParameter" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MintParam"+          , Context+              { cName = "MintParam"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '}' '['+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Verb" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Verb" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MintedEnvParam"+          , Context+              { cName = "MintedEnvParam"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '}' '['+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '}' '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "HighlightningSelector" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars ']' '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "HighlightningSelector" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Verbatim" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Multiline Comment"+          , Context+              { cName = "Multiline Comment"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "\\fi"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "\\else"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "NewCommand"+          , Context+              { cName = "NewCommand"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\{\\s*"+                              , reCompiled = Just (compileRegex True "\\s*\\{\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "LabelParameter" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*(\\[\\d\\](\\[[^\\]]*\\])?)?\\{"+                              , reCompiled =+                                  Just (compileRegex True "\\s*(\\[\\d\\](\\[[^\\]]*\\])?)?\\{")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "LabelParameter" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "NoWeb"+          , Context+              { cName = "NoWeb"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*@\\s*"+                              , reCompiled = Just (compileRegex True "\\s*@\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal Text"+          , Context+              { cName = "Normal Text"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\begin(?=[^a-zA-Z])"+                              , reCompiled = Just (compileRegex True "\\\\begin(?=[^a-zA-Z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "FindBeginEnvironment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\end(?=[^a-zA-Z])"+                              , reCompiled = Just (compileRegex True "\\\\end(?=[^a-zA-Z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "FindEndEnvironment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(cite|citet|citep|parencite|autocite|Autocite|citetitle)\\*(?=[^a-zA-Z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(cite|citet|citep|parencite|autocite|Autocite|citetitle)\\*(?=[^a-zA-Z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Label" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(documentclass|includegraphics|include|usepackage|bibliography|bibliographystyle)(?=[^a-zA-Z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(documentclass|includegraphics|include|usepackage|bibliography|bibliographystyle)(?=[^a-zA-Z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "FancyLabel" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(cites|Cites|parencites|Parencites|autocites|Autocites|supercites|footcites|Footcites)(?=[^a-zA-Z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(cites|Cites|parencites|Parencites|autocites|Autocites|supercites|footcites|Footcites)(?=[^a-zA-Z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "FancyLabel" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(cite|citet|citep|nocite|Cite|parencite|Parencite|footcite|Footcite|textcite|Textcite|supercite|autocite|Autocite|citeauthor|Citeauthor|citetitle|citeyear|citeurl|nocite|fullcite|footfullcite)(?=[^a-zA-Z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(cite|citet|citep|nocite|Cite|parencite|Parencite|footcite|Footcite|textcite|Textcite|supercite|autocite|Autocite|citeauthor|Citeauthor|citetitle|citeyear|citeurl|nocite|fullcite|footfullcite)(?=[^a-zA-Z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Label" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(subref\\*?|cref\\*?|label|pageref|autoref|ref|vpageref|vref|pagecite|eqref)(?=[^a-zA-Z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(subref\\*?|cref\\*?|label|pageref|autoref|ref|vpageref|vref|pagecite|eqref)(?=[^a-zA-Z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Label" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(part|chapter|section|subsection|subsubsection|paragraph|subparagraph)\\*?\\s*(?=[\\{\\[])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(part|chapter|section|subsection|subsubsection|paragraph|subparagraph)\\*?\\s*(?=[\\{\\[])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Sectioning" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(input|hspace|hspace\\*|vspace|vspace\\*|rule|special|setlength|newboolean|setboolean|setcounter|geometry|textcolor|definecolor|column)(?=[^a-zA-Z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(input|hspace|hspace\\*|vspace|vspace\\*|rule|special|setlength|newboolean|setboolean|setcounter|geometry|textcolor|definecolor|column)(?=[^a-zA-Z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "SpecialCommand" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(footnote)\\*?\\s*(?=[\\{\\[])"+                              , reCompiled =+                                  Just (compileRegex True "\\\\(footnote)\\*?\\s*(?=[\\{\\[])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Footnoting" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(renewcommand|providenewcommand|newcommand)\\*?(?=[^a-zA-Z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(renewcommand|providenewcommand|newcommand)\\*?(?=[^a-zA-Z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "NewCommand" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(e|g|x)?def(?=[^a-zA-Z])"+                              , reCompiled =+                                  Just (compileRegex True "\\\\(e|g|x)?def(?=[^a-zA-Z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "DefCommand" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<<.*>>="+                              , reCompiled = Just (compileRegex True "<<.*>>=")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "NoWeb" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "\\("+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathMode" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "\\["+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathModeEquation" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "\\iffalse"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Multiline Comment" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "\\ensuremath{"+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathModeEnsure" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "ContrSeq" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "$$"+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathModeDisplay" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathMode" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%\\s*BEGIN.*$"+                              , reCompiled = Just (compileRegex True "%\\s*BEGIN.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%\\s*END.*$"+                              , reCompiled = Just (compileRegex True "%\\s*END.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Sectioning"+          , Context+              { cName = "Sectioning"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[[^\\]]*\\]"+                              , reCompiled = Just (compileRegex True "\\[[^\\]]*\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ' '+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "SectioningInside" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "SectioningContrSeq"+          , Context+              { cName = "SectioningContrSeq"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z]+(\\+?|\\*{0,3})"+                              , reCompiled = Just (compileRegex True "[a-zA-Z]+(\\+?|\\*{0,3})")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^a-zA-Z]"+                              , reCompiled = Just (compileRegex True "[^a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SectioningInside"+          , Context+              { cName = "SectioningInside"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "SectioningInside" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "\\("+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "SectioningMathMode" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "SectioningContrSeq" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "SectioningMathMode" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SectioningMathContrSeq"+          , Context+              { cName = "SectioningMathContrSeq"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z]+\\*?"+                              , reCompiled = Just (compileRegex True "[a-zA-Z]+\\*?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^a-zA-Z]"+                              , reCompiled = Just (compileRegex True "[^a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = SpecialCharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SectioningMathMode"+          , Context+              { cName = "SectioningMathMode"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "$$"+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ')'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ']'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "SectioningMathContrSeq" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SpecialCommand"+          , Context+              { cName = "SpecialCommand"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\{\\s*"+                              , reCompiled = Just (compileRegex True "\\s*\\{\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "LaTeX" , "SpecialCommandParameterOption" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "SpecialCommandParameterOption"+          , Context+              { cName = "SpecialCommandParameterOption"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "\\("+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathMode" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "ContrSeq" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "MathMode" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\}\\s*"+                              , reCompiled = Just (compileRegex True "\\s*\\}\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Tab"+          , Context+              { cName = "Tab"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '&'+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "@{"+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Column Separator" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\end(?=\\s*\\{(tabularx|tabular|supertabular|mpsupertabular|xtabular|mpxtabular|longtable)\\*?\\})"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\end(?=\\s*\\{(tabularx|tabular|supertabular|mpsupertabular|xtabular|mpxtabular|longtable)\\*?\\})")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "TabFindEnd" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LaTeX" , "Normal Text" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "TabEnv"+          , Context+              { cName = "TabEnv"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Tab" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z]"+                              , reCompiled = Just (compileRegex True "[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LaTeX" , "EnvCommon" )+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ExtensionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop , Pop , Pop ]+              , cDynamic = False+              }+          )+        , ( "TabFindEnd"+          , Context+              { cName = "TabFindEnd"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\{"+                              , reCompiled = Just (compileRegex True "\\s*\\{")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(tabularx|tabular|supertabular|mpsupertabular|xtabular|mpxtabular|longtable)\\*?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(tabularx|tabular|supertabular|mpsupertabular|xtabular|mpxtabular|longtable)\\*?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "ToEndOfLine"+          , Context+              { cName = "ToEndOfLine"+              , cSyntax = "LaTeX"+              , cRules = []+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Verb"+          , Context+              { cName = "Verb"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(.)"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "VerbEnd" ) ]+                      }+                  ]+              , cAttribute = VerbatimStringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "VerbEnd"+          , Context+              { cName = "VerbEnd"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "%1"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^%1\\xd7]*"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = VerbatimStringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "VerbFindEnd"+          , Context+              { cName = "VerbFindEnd"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\{"+                              , reCompiled = Just (compileRegex True "\\s*\\{")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(verbatim|lstlisting|boxedverbatim|(B|L)?Verbatim|minted)\\*?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(verbatim|lstlisting|boxedverbatim|(B|L)?Verbatim|minted)\\*?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "Verbatim"+          , Context+              { cName = "Verbatim"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = InformationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\end(?=\\s*\\{(verbatim|lstlisting|boxedverbatim|(B|L)?Verbatim|minted)\\*?\\})"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\end(?=\\s*\\{(verbatim|lstlisting|boxedverbatim|(B|L)?Verbatim|minted)\\*?\\})")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "VerbFindEnd" ) ]+                      }+                  ]+              , cAttribute = VerbatimStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "VerbatimEnv"+          , Context+              { cName = "VerbatimEnv"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Verbatim" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z]"+                              , reCompiled = Just (compileRegex True "[a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LaTeX" , "EnvCommon" )+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ExtensionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop , Pop , Pop ]+              , cDynamic = False+              }+          )+        , ( "VerbatimEnvParam"+          , Context+              { cName = "VerbatimEnvParam"+              , cSyntax = "LaTeX"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '}' '['+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Verbatim" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LaTeX" , "Verbatim" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor =+      "Jeroen Wijnhout (Jeroen.Wijnhout@kdemail.net)+Holger Danielsson (holger.danielsson@versanet.de)+Michel Ludwig (michel.ludwig@kdemail.net)+Thomas Braun (thomas.braun@virtuell-zuhause.de)"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions =+      [ "*.tex"+      , "*.ltx"+      , "*.dtx"+      , "*.sty"+      , "*.cls"+      , "*.bbx"+      , "*.cbx"+      , "*.lbx"+      , "*.tikz"+      ]+  , sStartingContext = "Normal Text"+  }
+ src/Skylighting/Syntax/Lex.hs view
@@ -0,0 +1,1062 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Lex (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex++syntax :: Syntax+syntax = Syntax+  { sName = "Lex/Flex"+  , sFilename = "lex.xml"+  , sShortname = "Lex"+  , sContexts =+      fromList+        [ ( "Action"+          , Context+              { cName = "Action"+              , cSyntax = "Lex/Flex"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\|\\s*$"+                              , reCompiled = Just (compileRegex True "\\|\\s*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '%' '{'+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Lex/Flex" , "Lex Rule C Bloc" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Push ( "Lex/Flex" , "Action C" ) ]+              , cDynamic = False+              }+          )+        , ( "Action C"+          , Context+              { cName = "Action C"+              , cSyntax = "Lex/Flex"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Lex/Flex" , "Normal C Bloc" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "C++" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "Lex/Flex"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Definition RegExpr"+          , Context+              { cName = "Definition RegExpr"+              , cSyntax = "Lex/Flex"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Lex/Flex" , "RegExpr Base" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ".*"+                              , reCompiled = Just (compileRegex True ".*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Definitions"+          , Context+              { cName = "Definitions"+              , cSyntax = "Lex/Flex"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Lex/Flex" , "Detect C" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '%' '%'+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Lex/Flex" , "Rules" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Lex/Flex" , "Percent Command" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Lex/Flex" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Za-z_]\\w*\\s+"+                              , reCompiled = Just (compileRegex True "[A-Za-z_]\\w*\\s+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Lex/Flex" , "Definition RegExpr" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Detect C"+          , Context+              { cName = "Detect C"+              , cSyntax = "Lex/Flex"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s"+                              , reCompiled = Just (compileRegex True "\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Lex/Flex" , "Indented C" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '%' '{'+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Lex/Flex" , "Lex C Bloc" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Indented C"+          , Context+              { cName = "Indented C"+              , cSyntax = "Lex/Flex"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "C++" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Lex C Bloc"+          , Context+              { cName = "Lex C Bloc"+              , cSyntax = "Lex/Flex"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '%' '}'+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "C++" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Lex Rule C Bloc"+          , Context+              { cName = "Lex Rule C Bloc"+              , cSyntax = "Lex/Flex"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '%' '}'+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "C++" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal C Bloc"+          , Context+              { cName = "Normal C Bloc"+              , cSyntax = "Lex/Flex"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Lex/Flex" , "Normal C Bloc" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "C++" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Percent Command"+          , Context+              { cName = "Percent Command"+              , cSyntax = "Lex/Flex"+              , cRules = []+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Pre Start"+          , Context+              { cName = "Pre Start"+              , cSyntax = "Lex/Flex"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Lex/Flex" , "Definitions" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RegExpr ("+          , Context+              { cName = "RegExpr ("+              , cSyntax = "Lex/Flex"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Lex/Flex" , "RegExpr Base" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RegExpr Base"+          , Context+              { cName = "RegExpr Base"+              , cSyntax = "Lex/Flex"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Lex/Flex" , "RegExpr (" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Lex/Flex" , "RegExpr [" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Lex/Flex" , "RegExpr {" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Lex/Flex" , "RegExpr Q" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RegExpr Q"+          , Context+              { cName = "RegExpr Q"+              , cSyntax = "Lex/Flex"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RegExpr ["+          , Context+              { cName = "RegExpr ["+              , cSyntax = "Lex/Flex"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RegExpr {"+          , Context+              { cName = "RegExpr {"+              , cSyntax = "Lex/Flex"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Rule RegExpr"+          , Context+              { cName = "Rule RegExpr"+              , cSyntax = "Lex/Flex"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{$"+                              , reCompiled = Just (compileRegex True "\\{$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Lex/Flex" , "Start Conditions Scope" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Lex/Flex" , "RegExpr Base" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+"+                              , reCompiled = Just (compileRegex True "\\s+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Lex/Flex" , "Action" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Rules"+          , Context+              { cName = "Rules"+              , cSyntax = "Lex/Flex"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Lex/Flex" , "Detect C" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '%' '%'+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Lex/Flex" , "User Code" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Push ( "Lex/Flex" , "Rule RegExpr" ) ]+              , cDynamic = False+              }+          )+        , ( "Start Conditions Scope"+          , Context+              { cName = "Start Conditions Scope"+              , cSyntax = "Lex/Flex"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\}"+                              , reCompiled = Just (compileRegex True "\\s*\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*"+                              , reCompiled = Just (compileRegex True "\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Lex/Flex" , "Rule RegExpr" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Push ( "Lex/Flex" , "Rule RegExpr" ) ]+              , cDynamic = False+              }+          )+        , ( "User Code"+          , Context+              { cName = "User Code"+              , cSyntax = "Lex/Flex"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "C++" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Jan Villat (jan.villat@net2000.ch)"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions = [ "*.l" , "*.lex" , "*.flex" ]+  , sStartingContext = "Pre Start"+  }
+ src/Skylighting/Syntax/Lilypond.hs view
@@ -0,0 +1,5876 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Lilypond (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "LilyPond"+  , sFilename = "lilypond.xml"+  , sShortname = "Lilypond"+  , sContexts =+      fromList+        [ ( "assignment"+          , Context+              { cName = "assignment"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b(dash(Hat|Plus|Dash|Bar|Larger|Dot|Underscore)|fermataMarkup|pipeSymbol|slashSeparator)\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\b(dash(Hat|Plus|Dash|Bar|Larger|Dot|Underscore)|fermataMarkup|pipeSymbol|slashSeparator)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-z]+"+                              , reCompiled = Just (compileRegex False "[a-z]+")+                              , reCaseSensitive = False+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "basic"+          , Context+              { cName = "basic"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '%' '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "commentblock" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "commentline" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "string" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "scheme" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "schemesub" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "chord"+          , Context+              { cName = "chord"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "chordend" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z]))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z]))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "chordpitch" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "<{}srR"+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "music" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "chordend"+          , Context+              { cName = "chordend"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\\\(longa|breve)\\b|(1|2|4|8|16|32|64|128|256|512|1024|2048)(?!\\d))(\\s*\\.+)?(\\s*\\*\\s*\\d+(/\\d+)?)*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(\\\\(longa|breve)\\b|(1|2|4|8|16|32|64|128|256|512|1024|2048)(?!\\d))(\\s*\\.+)?(\\s*\\*\\s*\\d+(/\\d+)?)*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop , Pop ]+              , cDynamic = False+              }+          )+        , ( "chordmode"+          , Context+              { cName = "chordmode"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "chordmode2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "chordmode2"+          , Context+              { cName = "chordmode2"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "chordrules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "chordpitch"+          , Context+              { cName = "chordpitch"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "=\\s*('+|,+)?"+                              , reCompiled = Just (compileRegex True "=\\s*('+|,+)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\\\(longa|breve)\\b|(1|2|4|8|16|32|64|128|256|512|1024|2048)(?!\\d))(\\s*\\.+)?(\\s*\\*\\s*\\d+(/\\d+)?)*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(\\\\(longa|breve)\\b|(1|2|4|8|16|32|64|128|256|512|1024|2048)(?!\\d))(\\s*\\.+)?(\\s*\\*\\s*\\d+(/\\d+)?)*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\d+"+                              , reCompiled = Just (compileRegex True "\\d+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "chordrules"+          , Context+              { cName = "chordrules"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "chordrules" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  ":?([\\.^]?\\d+[-+]?|(m|dim|aug|maj|sus)(?![A-Za-z]))*(/\\+?\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z])))?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       ":?([\\.^]?\\d+[-+]?|(m|dim|aug|maj|sus)(?![A-Za-z]))*(/\\+?\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z])))?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "music" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "command"+          , Context+              { cName = "command"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\note(mode|s)(?![A-Za-z])"+                              , reCompiled =+                                  Just (compileRegex True "\\\\note(mode|s)(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "notemode" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\drum(mode|s)(?![A-Za-z])"+                              , reCompiled =+                                  Just (compileRegex True "\\\\drum(mode|s)(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "drummode" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\chord(mode|s)(?![A-Za-z])"+                              , reCompiled =+                                  Just (compileRegex True "\\\\chord(mode|s)(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "chordmode" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\figure(mode|s)(?![A-Za-z])"+                              , reCompiled =+                                  Just (compileRegex True "\\\\figure(mode|s)(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "figuremode" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(lyric(mode|s)|addlyrics)(?![A-Za-z])"+                              , reCompiled =+                                  Just+                                    (compileRegex True "\\\\(lyric(mode|s)|addlyrics)(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "lyricmode" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\lyricsto(?![A-Za-z])"+                              , reCompiled = Just (compileRegex True "\\\\lyricsto(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "lyricsto" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\markup(lines)?(?![A-Za-z])"+                              , reCompiled =+                                  Just (compileRegex True "\\\\markup(lines)?(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "markup" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(header|paper|layout|midi|with)\\b"+                              , reCompiled =+                                  Just (compileRegex True "\\\\(header|paper|layout|midi|with)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "section" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(new|context|change)\\b"+                              , reCompiled =+                                  Just (compileRegex True "\\\\(new|context|change)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "context" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(un)?set\\b"+                              , reCompiled = Just (compileRegex True "\\\\(un)?set\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "set" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(override(Property)?|revert)(?![A-Za-z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\\\(override(Property)?|revert)(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "override" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\skip(?![A-Za-z])"+                              , reCompiled = Just (compileRegex True "\\\\skip(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "duration" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\tempo(?![A-Za-z])"+                              , reCompiled = Just (compileRegex True "\\\\tempo(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "tempo" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(accepts|alias|consists|defaultchild|denies|description|grobdescriptions|include|invalid|language|name|objectid|once|remove|sequential|simultaneous|type|version|score|book|bookpart)(?![A-Za-z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(accepts|alias|consists|defaultchild|denies|description|grobdescriptions|include|invalid|language|name|objectid|once|remove|sequential|simultaneous|type|version|score|book|bookpart)(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\((aiken|funk|sacredHarp|southernHarmony|walker)Heads(Minor)?)(?![A-Za-z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\((aiken|funk|sacredHarp|southernHarmony|walker)Heads(Minor)?)(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(acciaccatura|addQuote|afterGrace|allowPageTurn|alternative|apply(Context|Music|Output)|appoggiatura|arpeggio(Arrow(Down|Up)|Bracket|Normal|Parenthesis)?|(a|de)scendens|auctum|augmentum|autoBeamO(ff|n)|autochange|balloon(Grob)?Text|bar|barNumberCheck|bendAfter|breathe|break|cadenzaO(ff|n)|cavum|clef(\\s+(treble|violin|G|alto|C|tenor|(sub)?bass|F|french|(mezzo)?soprano|(var)?baritone|percussion|tab))?|(end)?(de)?cr|cresc(TextCresc|Hairpin))(?![A-Za-z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(acciaccatura|addQuote|afterGrace|allowPageTurn|alternative|apply(Context|Music|Output)|appoggiatura|arpeggio(Arrow(Down|Up)|Bracket|Normal|Parenthesis)?|(a|de)scendens|auctum|augmentum|autoBeamO(ff|n)|autochange|balloon(Grob)?Text|bar|barNumberCheck|bendAfter|breathe|break|cadenzaO(ff|n)|cavum|clef(\\s+(treble|violin|G|alto|C|tenor|(sub)?bass|F|french|(mezzo)?soprano|(var)?baritone|percussion|tab))?|(end)?(de)?cr|cresc(TextCresc|Hairpin))(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\((cue|transposedCue)During|default|deminutum|dim(Text(Decresc|Decr|Dim)|Hairpin)|display(Lily)?Music|divisio(Maior|Maxima|Minima)|(dynamic|dots|phrasingSlur|slur|stem|tie|tuplet)(Down|Neutral|Up)|(balloon|text)LengthO(ff|n)|featherDurations|figure(mode|s)|finalis|flexa|(french|german|italian|semiGerman)Chords|glissando|grace|harmonic|(unH|h)ideNotes|(hide|show)StaffSwitch|inclinatum|(keep|remove)WithTag|key(\\s+\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z])))?|killCues)(?![A-Za-z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\((cue|transposedCue)During|default|deminutum|dim(Text(Decresc|Decr|Dim)|Hairpin)|display(Lily)?Music|divisio(Maior|Maxima|Minima)|(dynamic|dots|phrasingSlur|slur|stem|tie|tuplet)(Down|Neutral|Up)|(balloon|text)LengthO(ff|n)|featherDurations|figure(mode|s)|finalis|flexa|(french|german|italian|semiGerman)Chords|glissando|grace|harmonic|(unH|h)ideNotes|(hide|show)StaffSwitch|inclinatum|(keep|remove)WithTag|key(\\s+\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z])))?|killCues)(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(label|laissezVibrer|linea|makeClusters|mark|maxima|melisma(End)?|mergeDifferently(Head|Dott)edO(ff|n)|newSpacingSection|no(Beam|Break|PageBreak|PageTurn)|normalsize|numericTimeSignature|octaveCheck|oneVoice|oriscus|ottava|page(-ref|Break|Turn)|parallelMusic|parenthesize|partcombine|partial(\\s*(\\\\(longa|breve)\\b|(1|2|4|8|16|32|64|128|256|512|1024|2048)(?!\\d))(\\s*\\.+)?(\\s*\\*\\s*\\d+(/\\d+)?)*)?|pes|pitchedTrill)(?![A-Za-z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(label|laissezVibrer|linea|makeClusters|mark|maxima|melisma(End)?|mergeDifferently(Head|Dott)edO(ff|n)|newSpacingSection|no(Beam|Break|PageBreak|PageTurn)|normalsize|numericTimeSignature|octaveCheck|oneVoice|oriscus|ottava|page(-ref|Break|Turn)|parallelMusic|parenthesize|partcombine|partial(\\s*(\\\\(longa|breve)\\b|(1|2|4|8|16|32|64|128|256|512|1024|2048)(?!\\d))(\\s*\\.+)?(\\s*\\*\\s*\\d+(/\\d+)?)*)?|pes|pitchedTrill)(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(pointAndClickO(ff|n)|quilisma|quoteDuring|relative(\\s+\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z])))?|RemoveEmptyStaffContext|repeat(\\s+(unfold|volta|tremolo|percent)(\\s+\\d+)?)?|repeatTie|resetRelativeOctave|rest|scaleDurations|scoreTweak|easyHeadsO(ff|n)|shift(Durations|Off|On{1,3})|(slur|tie)(Both|Dashed|Dotted|Solid)|small|spacingTweaks)(?![A-Za-z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(pointAndClickO(ff|n)|quilisma|quoteDuring|relative(\\s+\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z])))?|RemoveEmptyStaffContext|repeat(\\s+(unfold|volta|tremolo|percent)(\\s+\\d+)?)?|repeatTie|resetRelativeOctave|rest|scaleDurations|scoreTweak|easyHeadsO(ff|n)|shift(Durations|Off|On{1,3})|(slur|tie)(Both|Dashed|Dotted|Solid)|small|spacingTweaks)(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\((start|stop)(Group|(Text|Trill)Span|Staff)|stemBoth|stropha|super|(sustain|sostenuto)O(ff|n)|table-of-contents|tag|times?(\\s*\\d+/\\d+)?|tiny|tocItem)(?![A-Za-z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\((start|stop)(Group|(Text|Trill)Span|Staff)|stemBoth|stropha|super|(sustain|sostenuto)O(ff|n)|table-of-contents|tag|times?(\\s*\\d+/\\d+)?|tiny|tocItem)(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(transpose(\\s+\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z]))\\s*\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z])))?|transposition(\\s+\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z]))))(?![A-Za-z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(transpose(\\s+\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z]))\\s*\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z])))?|transposition(\\s+\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z]))))(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(tweak|unfoldRepeats|virg(ul)?a|voice(One|Two|Three|Four)|withMusicProperty|cm|mm|in|pt|major|minor|ionian|locrian|aeolian|mixolydian|lydian|phrygian|dorian)(?![A-Za-z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(tweak|unfoldRepeats|virg(ul)?a|voice(One|Two|Three|Four)|withMusicProperty|cm|mm|in|pt|major|minor|ionian|locrian|aeolian|mixolydian|lydian|phrygian|dorian)(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(dash(Hat|Plus|Dash|Bar|Larger|Dot|Underscore)|fermataMarkup|pipeSymbol|slashSeparator)(?![A-Za-z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(dash(Hat|Plus|Dash|Bar|Larger|Dot|Underscore)|fermataMarkup|pipeSymbol|slashSeparator)(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(consistsend)(?![A-Za-z])"+                              , reCompiled =+                                  Just (compileRegex True "\\\\(consistsend)(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(arpeggio(Up|Down|Neutral)|newpage|script(Up|Down|Both)|(empty|fat)Text|setEasyHeads|(default|voice|modernVoice|piano|forget)Accidentals|(modern(Voice)?|piano)Cautionaries|noResetKey|compressMusic|octave|(sustain|sostenuto)(Down|Up)|set(Hairpin|Text)(Cresc|Decresc|Dim)|setTextDecr)(?![A-Za-z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(arpeggio(Up|Down|Neutral)|newpage|script(Up|Down|Both)|(empty|fat)Text|setEasyHeads|(default|voice|modernVoice|piano|forget)Accidentals|(modern(Voice)?|piano)Cautionaries|noResetKey|compressMusic|octave|(sustain|sostenuto)(Down|Up)|set(Hairpin|Text)(Cresc|Decresc|Dim)|setTextDecr)(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(translator|newcontext)\\b"+                              , reCompiled =+                                  Just (compileRegex True "\\\\(translator|newcontext)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "context" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\property(?![A-Za-z])"+                              , reCompiled = Just (compileRegex True "\\\\property(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "override" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[A-Za-z]+"+                              , reCompiled = Just (compileRegex True "\\\\[A-Za-z]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "commentblock"+          , Context+              { cName = "commentblock"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '%' '}'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "commentline"+          , Context+              { cName = "commentline"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "connect"+          , Context+              { cName = "connect"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = AnyChar ".-+|>^_12345"+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "context"+          , Context+              { cName = "context"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&'()*+,-./0123456789:;<=>?[\\]^_{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ChoirStaff"+                               , "ChordNames"+                               , "CueVoice"+                               , "Devnull"+                               , "DrumStaff"+                               , "DrumVoice"+                               , "Dynamics"+                               , "FiguredBass"+                               , "FretBoards"+                               , "Global"+                               , "GrandStaff"+                               , "GregorianTranscriptionStaff"+                               , "GregorianTranscriptionVoice"+                               , "Lyrics"+                               , "MensuralStaff"+                               , "MensuralVoice"+                               , "NoteNames"+                               , "PianoStaff"+                               , "RhythmicStaff"+                               , "Score"+                               , "Staff"+                               , "StaffGroup"+                               , "TabStaff"+                               , "TabVoice"+                               , "Timing"+                               , "VaticanaStaff"+                               , "VaticanaVoice"+                               , "Voice"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "context2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&'()*+,-./0123456789:;<=>?[\\]^_{|}~"+                              }+                            (makeWordSet True [ "InnerChoirStaff" , "InnerStaffGroup" ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "context2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Za-z]+"+                              , reCompiled = Just (compileRegex True "[A-Za-z]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "context2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "section2" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "context2"+          , Context+              { cName = "context2"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "=(\\s*[A-Za-z]+)?"+                              , reCompiled = Just (compileRegex True "=(\\s*[A-Za-z]+)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop , Pop ]+              , cDynamic = False+              }+          )+        , ( "default"+          , Context+              { cName = "default"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '<' '<'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '>' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '|'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "command" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "basic" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "drumchord"+          , Context+              { cName = "drumchord"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&'()*+,-./0123456789:;<=>?[\\]^_{|}~"+                              }+                            (makeWordSet+                               True+                               [ "acousticbassdrum"+                               , "acousticsnare"+                               , "agh"+                               , "agl"+                               , "bassdrum"+                               , "bd"+                               , "bda"+                               , "boh"+                               , "bohm"+                               , "boho"+                               , "bol"+                               , "bolm"+                               , "bolo"+                               , "cab"+                               , "cabasa"+                               , "cb"+                               , "cgh"+                               , "cghm"+                               , "cgho"+                               , "cgl"+                               , "cglm"+                               , "cglo"+                               , "chinesecymbal"+                               , "cl"+                               , "claves"+                               , "closedhihat"+                               , "cowbell"+                               , "crashcymbal"+                               , "crashcymbala"+                               , "crashcymbalb"+                               , "cuim"+                               , "cuio"+                               , "cymc"+                               , "cymca"+                               , "cymcb"+                               , "cymch"+                               , "cymr"+                               , "cymra"+                               , "cymrb"+                               , "cyms"+                               , "da"+                               , "db"+                               , "dc"+                               , "dd"+                               , "de"+                               , "electricsnare"+                               , "fivedown"+                               , "fiveup"+                               , "fourdown"+                               , "fourup"+                               , "gui"+                               , "guil"+                               , "guiro"+                               , "guis"+                               , "halfopenhihat"+                               , "handclap"+                               , "hc"+                               , "hh"+                               , "hhc"+                               , "hhho"+                               , "hho"+                               , "hhp"+                               , "hiagogo"+                               , "hibongo"+                               , "hiconga"+                               , "highfloortom"+                               , "hightom"+                               , "hihat"+                               , "himidtom"+                               , "hisidestick"+                               , "hitimbale"+                               , "hiwoodblock"+                               , "loagogo"+                               , "lobongo"+                               , "loconga"+                               , "longguiro"+                               , "longwhistle"+                               , "losidestick"+                               , "lotimbale"+                               , "lowfloortom"+                               , "lowmidtom"+                               , "lowoodblock"+                               , "lowtom"+                               , "mar"+                               , "maracas"+                               , "mutecuica"+                               , "mutehibongo"+                               , "mutehiconga"+                               , "mutelobongo"+                               , "muteloconga"+                               , "mutetriangle"+                               , "onedown"+                               , "oneup"+                               , "opencuica"+                               , "openhibongo"+                               , "openhiconga"+                               , "openhihat"+                               , "openlobongo"+                               , "openloconga"+                               , "opentriangle"+                               , "pedalhihat"+                               , "rb"+                               , "ridebell"+                               , "ridecymbal"+                               , "ridecymbala"+                               , "ridecymbalb"+                               , "shortguiro"+                               , "shortwhistle"+                               , "sidestick"+                               , "sn"+                               , "sna"+                               , "snare"+                               , "sne"+                               , "splashcymbal"+                               , "ss"+                               , "ssh"+                               , "ssl"+                               , "tamb"+                               , "tambourine"+                               , "tamtam"+                               , "threedown"+                               , "threeup"+                               , "timh"+                               , "timl"+                               , "tomfh"+                               , "tomfl"+                               , "tomh"+                               , "toml"+                               , "tommh"+                               , "tomml"+                               , "tri"+                               , "triangle"+                               , "trim"+                               , "trio"+                               , "tt"+                               , "twodown"+                               , "twoup"+                               , "ua"+                               , "ub"+                               , "uc"+                               , "ud"+                               , "ue"+                               , "vibraslap"+                               , "vibs"+                               , "wbh"+                               , "wbl"+                               , "whl"+                               , "whs"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "chord" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "drummode"+          , Context+              { cName = "drummode"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "drummode2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "drummode2"+          , Context+              { cName = "drummode2"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "drumrules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "drumrules"+          , Context+              { cName = "drumrules"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "drumrules" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<(?!<)"+                              , reCompiled = Just (compileRegex True "<(?!<)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "drumchord" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&'()*+,-./0123456789:;<=>?[\\]^_{|}~"+                              }+                            (makeWordSet+                               True+                               [ "acousticbassdrum"+                               , "acousticsnare"+                               , "agh"+                               , "agl"+                               , "bassdrum"+                               , "bd"+                               , "bda"+                               , "boh"+                               , "bohm"+                               , "boho"+                               , "bol"+                               , "bolm"+                               , "bolo"+                               , "cab"+                               , "cabasa"+                               , "cb"+                               , "cgh"+                               , "cghm"+                               , "cgho"+                               , "cgl"+                               , "cglm"+                               , "cglo"+                               , "chinesecymbal"+                               , "cl"+                               , "claves"+                               , "closedhihat"+                               , "cowbell"+                               , "crashcymbal"+                               , "crashcymbala"+                               , "crashcymbalb"+                               , "cuim"+                               , "cuio"+                               , "cymc"+                               , "cymca"+                               , "cymcb"+                               , "cymch"+                               , "cymr"+                               , "cymra"+                               , "cymrb"+                               , "cyms"+                               , "da"+                               , "db"+                               , "dc"+                               , "dd"+                               , "de"+                               , "electricsnare"+                               , "fivedown"+                               , "fiveup"+                               , "fourdown"+                               , "fourup"+                               , "gui"+                               , "guil"+                               , "guiro"+                               , "guis"+                               , "halfopenhihat"+                               , "handclap"+                               , "hc"+                               , "hh"+                               , "hhc"+                               , "hhho"+                               , "hho"+                               , "hhp"+                               , "hiagogo"+                               , "hibongo"+                               , "hiconga"+                               , "highfloortom"+                               , "hightom"+                               , "hihat"+                               , "himidtom"+                               , "hisidestick"+                               , "hitimbale"+                               , "hiwoodblock"+                               , "loagogo"+                               , "lobongo"+                               , "loconga"+                               , "longguiro"+                               , "longwhistle"+                               , "losidestick"+                               , "lotimbale"+                               , "lowfloortom"+                               , "lowmidtom"+                               , "lowoodblock"+                               , "lowtom"+                               , "mar"+                               , "maracas"+                               , "mutecuica"+                               , "mutehibongo"+                               , "mutehiconga"+                               , "mutelobongo"+                               , "muteloconga"+                               , "mutetriangle"+                               , "onedown"+                               , "oneup"+                               , "opencuica"+                               , "openhibongo"+                               , "openhiconga"+                               , "openhihat"+                               , "openlobongo"+                               , "openloconga"+                               , "opentriangle"+                               , "pedalhihat"+                               , "rb"+                               , "ridebell"+                               , "ridecymbal"+                               , "ridecymbala"+                               , "ridecymbalb"+                               , "shortguiro"+                               , "shortwhistle"+                               , "sidestick"+                               , "sn"+                               , "sna"+                               , "snare"+                               , "sne"+                               , "splashcymbal"+                               , "ss"+                               , "ssh"+                               , "ssl"+                               , "tamb"+                               , "tambourine"+                               , "tamtam"+                               , "threedown"+                               , "threeup"+                               , "timh"+                               , "timl"+                               , "tomfh"+                               , "tomfl"+                               , "tomh"+                               , "toml"+                               , "tommh"+                               , "tomml"+                               , "tri"+                               , "triangle"+                               , "trim"+                               , "trio"+                               , "tt"+                               , "twodown"+                               , "twoup"+                               , "ua"+                               , "ub"+                               , "uc"+                               , "ud"+                               , "ue"+                               , "vibraslap"+                               , "vibs"+                               , "wbh"+                               , "wbl"+                               , "whl"+                               , "whs"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "duration" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "music" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "duration"+          , Context+              { cName = "duration"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\\\(longa|breve)\\b|(1|2|4|8|16|32|64|128|256|512|1024|2048)(?!\\d))(\\s*\\.+)?(\\s*\\*\\s*\\d+(/\\d+)?)*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(\\\\(longa|breve)\\b|(1|2|4|8|16|32|64|128|256|512|1024|2048)(?!\\d))(\\s*\\.+)?(\\s*\\*\\s*\\d+(/\\d+)?)*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\d+"+                              , reCompiled = Just (compileRegex True "\\d+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "figure"+          , Context+              { cName = "figure"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "chordend" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "basic" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\markup(lines)?(?![A-Za-z])"+                              , reCompiled =+                                  Just (compileRegex True "\\\\markup(lines)?(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "markup" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\skip(?![A-Za-z])"+                              , reCompiled = Just (compileRegex True "\\\\skip(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "duration" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "figuremode"+          , Context+              { cName = "figuremode"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "figuremode2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "figuremode2"+          , Context+              { cName = "figuremode2"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "figurerules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "figurerules"+          , Context+              { cName = "figurerules"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "figurerules" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "figure" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[srR](?![A-Za-z])"+                              , reCompiled = Just (compileRegex True "\\b[srR](?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "duration" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "default" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "lilypond"+          , Context+              { cName = "lilypond"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "music" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[a-z]+\\s*="+                              , reCompiled = Just (compileRegex False "\\b[a-z]+\\s*=")+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "assignment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "lyricmode"+          , Context+              { cName = "lyricmode"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "lyricmode2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "lyricmode2"+          , Context+              { cName = "lyricmode2"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "lyricrules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "lyricrules"+          , Context+              { cName = "lyricrules"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "lyricrules" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\w+-{2,}|\\w+_{2,}|-{2,}\\w+|_{2,}\\w+)"+                              , reCompiled =+                                  Just+                                    (compileRegex True "(\\w+-{2,}|\\w+_{2,}|-{2,}\\w+|_{2,}\\w+)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\\\(longa|breve)\\b|(1|2|4|8|16|32|64|128|256|512|1024|2048)(?!\\d))(\\s*\\.+)?(\\s*\\*\\s*\\d+(/\\d+)?)*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(\\\\(longa|breve)\\b|(1|2|4|8|16|32|64|128|256|512|1024|2048)(?!\\d))(\\s*\\.+)?(\\s*\\*\\s*\\d+(/\\d+)?)*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(--|__|_)"+                              , reCompiled = Just (compileRegex True "(--|__|_)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "default" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S+\\}"+                              , reCompiled = Just (compileRegex True "\\S+\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "lyricsto"+          , Context+              { cName = "lyricsto"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"(\\\\[\"\\\\]|[^\"\\\\])+\""+                              , reCompiled =+                                  Just (compileRegex True "\"(\\\\[\"\\\\]|[^\"\\\\])+\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "lyricsto2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Za-z]+"+                              , reCompiled = Just (compileRegex True "[A-Za-z]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "lyricsto2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "lyricsto2"+          , Context+              { cName = "lyricsto2"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "lyricsto3" ) ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop , Pop ]+              , cDynamic = False+              }+          )+        , ( "lyricsto3"+          , Context+              { cName = "lyricsto3"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "lyricrules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "markup"+          , Context+              { cName = "markup"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "markup2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\score\\b"+                              , reCompiled = Just (compileRegex True "\\\\score\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "notemode" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(markup|bold|(rounded-)?box|bracket|caps|(center|general|left|right)-align|circle|((center|dir|left|right)-)?column|combine|concat|dynamic|fill-line|finger|fontCaps|(abs-)?fontsize|fraction|halign|hbracket|hcenter-in|hcenter|hspace|huge|italic|justify|larger?|line|lower|magnify|medium|normal-size-(sub|super)|normal-text|normalsize|number|on-the-fly|override|pad-(around|markup|to-box|x)|page-ref|postscript|put-adjacent|raise|roman|rotate|sans|small(er)?|smallCaps|sub|super|teeny|text|tiny|translate(-scaled)?|transparent|typewriter|underline|upright|vcenter|whiteout|with-(color|dimensions|url)|wordwrap|(markup|column-|justified-|override-|wordwrap-)lines|wordwrap-(string-)?internal)(?![A-Za-z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(markup|bold|(rounded-)?box|bracket|caps|(center|general|left|right)-align|circle|((center|dir|left|right)-)?column|combine|concat|dynamic|fill-line|finger|fontCaps|(abs-)?fontsize|fraction|halign|hbracket|hcenter-in|hcenter|hspace|huge|italic|justify|larger?|line|lower|magnify|medium|normal-size-(sub|super)|normal-text|normalsize|number|on-the-fly|override|pad-(around|markup|to-box|x)|page-ref|postscript|put-adjacent|raise|roman|rotate|sans|small(er)?|smallCaps|sub|super|teeny|text|tiny|translate(-scaled)?|transparent|typewriter|underline|upright|vcenter|whiteout|with-(color|dimensions|url)|wordwrap|(markup|column-|justified-|override-|wordwrap-)lines|wordwrap-(string-)?internal)(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(arrow-head|beam|char|(semi|sesqui|double)?(flat|sharp)|draw-(circle|line)|epsfile|eyeglasses|filled-box|fret-diagram(-terse|-verbose)?|fromproperty|harp-pedal|(justify|wordwrap)-(field|string)|left-brace|lookup|markalphabet|markletter|musicglyph|natural|note-by-number|note|null|path|right-brace|simple|(back)?slashed-digit|stencil|strut|tied-lyric|triangle|verbatim-file)(?![A-Za-z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(arrow-head|beam|char|(semi|sesqui|double)?(flat|sharp)|draw-(circle|line)|epsfile|eyeglasses|filled-box|fret-diagram(-terse|-verbose)?|fromproperty|harp-pedal|(justify|wordwrap)-(field|string)|left-brace|lookup|markalphabet|markletter|musicglyph|natural|note-by-number|note|null|path|right-brace|simple|(back)?slashed-digit|stencil|strut|tied-lyric|triangle|verbatim-file)(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "scheme" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^\"\\s\\\\#%{}$]+"+                              , reCompiled = Just (compileRegex True "[^\"\\s\\\\#%{}$]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "markup2"+          , Context+              { cName = "markup2"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "markuprules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "markuprules"+          , Context+              { cName = "markuprules"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "markuprules" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\score\\b"+                              , reCompiled = Just (compileRegex True "\\\\score\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "notemode" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(arrow-head|beam|char|(semi|sesqui|double)?(flat|sharp)|draw-(circle|line)|epsfile|eyeglasses|filled-box|fret-diagram(-terse|-verbose)?|fromproperty|harp-pedal|(justify|wordwrap)-(field|string)|left-brace|lookup|markalphabet|markletter|musicglyph|natural|note-by-number|note|null|path|right-brace|simple|(back)?slashed-digit|stencil|strut|tied-lyric|triangle|verbatim-file|markup|bold|(rounded-)?box|bracket|caps|(center|general|left|right)-align|circle|((center|dir|left|right)-)?column|combine|concat|dynamic|fill-line|finger|fontCaps|(abs-)?fontsize|fraction|halign|hbracket|hcenter-in|hcenter|hspace|huge|italic|justify|larger?|line|lower|magnify|medium|normal-size-(sub|super)|normal-text|normalsize|number|on-the-fly|override|pad-(around|markup|to-box|x)|page-ref|postscript|put-adjacent|raise|roman|rotate|sans|small(er)?|smallCaps|sub|super|teeny|text|tiny|translate(-scaled)?|transparent|typewriter|underline|upright|vcenter|whiteout|with-(color|dimensions|url)|wordwrap|(markup|column-|justified-|override-|wordwrap-)lines|wordwrap-(string-)?internal)(?![A-Za-z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(arrow-head|beam|char|(semi|sesqui|double)?(flat|sharp)|draw-(circle|line)|epsfile|eyeglasses|filled-box|fret-diagram(-terse|-verbose)?|fromproperty|harp-pedal|(justify|wordwrap)-(field|string)|left-brace|lookup|markalphabet|markletter|musicglyph|natural|note-by-number|note|null|path|right-brace|simple|(back)?slashed-digit|stencil|strut|tied-lyric|triangle|verbatim-file|markup|bold|(rounded-)?box|bracket|caps|(center|general|left|right)-align|circle|((center|dir|left|right)-)?column|combine|concat|dynamic|fill-line|finger|fontCaps|(abs-)?fontsize|fraction|halign|hbracket|hcenter-in|hcenter|hspace|huge|italic|justify|larger?|line|lower|magnify|medium|normal-size-(sub|super)|normal-text|normalsize|number|on-the-fly|override|pad-(around|markup|to-box|x)|page-ref|postscript|put-adjacent|raise|roman|rotate|sans|small(er)?|smallCaps|sub|super|teeny|text|tiny|translate(-scaled)?|transparent|typewriter|underline|upright|vcenter|whiteout|with-(color|dimensions|url)|wordwrap|(markup|column-|justified-|override-|wordwrap-)lines|wordwrap-(string-)?internal)(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(bigger|h?center)(?![A-Za-z])"+                              , reCompiled =+                                  Just (compileRegex True "\\\\(bigger|h?center)(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[A-Za-z]+(-[A-Za-z]+)*"+                              , reCompiled =+                                  Just (compileRegex True "\\\\[A-Za-z]+(-[A-Za-z]+)*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "basic" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "music"+          , Context+              { cName = "music"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = AnyChar "()~"+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "[]"+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "-_^"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "connect" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "musiccommand" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "default" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "chord" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-z]+\\d+\\.*[,']+"+                              , reCompiled = Just (compileRegex True "[a-z]+\\d+\\.*[,']+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b[srR](?![A-Za-z])|\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z])))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(\\b[srR](?![A-Za-z])|\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z])))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "pitch" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ":\\d*"+                              , reCompiled = Just (compileRegex True ":\\d*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "musiccommand"+          , Context+              { cName = "musiccommand"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(p{1,5}|mp|mf|f{1,5}|s?fp|sff?|spp?|[sr]?fz|cresc|decresc|dim)(?![A-Za-z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(p{1,5}|mp|mf|f{1,5}|s?fp|sff?|spp?|[sr]?fz|cresc|decresc|dim)(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[<!>]"+                              , reCompiled = Just (compileRegex True "\\\\[<!>]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(\\d+|accent|marcato|staccat(issim)?o|espressivo|tenuto|portato|(up|down)(bow|mordent|prall)|flageolet|thumb|[lr](heel|toe)|open|stopped|turn|reverseturn|trill|mordent|prall(prall|mordent|down|up)?|lineprall|signumcongruentiae|(short|long|verylong)?fermata|segno|(var)?coda|snappizzicato|halfopen)(?![A-Za-z])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(\\d+|accent|marcato|staccat(issim)?o|espressivo|tenuto|portato|(up|down)(bow|mordent|prall)|flageolet|thumb|[lr](heel|toe)|open|stopped|turn|reverseturn|trill|mordent|prall(prall|mordent|down|up)?|lineprall|signumcongruentiae|(short|long|verylong)?fermata|segno|(var)?coda|snappizzicato|halfopen)(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[()]"+                              , reCompiled = Just (compileRegex True "\\\\[()]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[][]"+                              , reCompiled = Just (compileRegex True "\\\\[][]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "command" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "notemode"+          , Context+              { cName = "notemode"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "notemode2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "notemode2"+          , Context+              { cName = "notemode2"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "noterules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "noterules"+          , Context+              { cName = "noterules"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "noterules" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "music" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "override"+          , Context+              { cName = "override"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&'()*+,-./0123456789:;<=>?[\\]^_{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ChoirStaff"+                               , "ChordNames"+                               , "CueVoice"+                               , "Devnull"+                               , "DrumStaff"+                               , "DrumVoice"+                               , "Dynamics"+                               , "FiguredBass"+                               , "FretBoards"+                               , "Global"+                               , "GrandStaff"+                               , "GregorianTranscriptionStaff"+                               , "GregorianTranscriptionVoice"+                               , "Lyrics"+                               , "MensuralStaff"+                               , "MensuralVoice"+                               , "NoteNames"+                               , "PianoStaff"+                               , "RhythmicStaff"+                               , "Score"+                               , "Staff"+                               , "StaffGroup"+                               , "TabStaff"+                               , "TabVoice"+                               , "Timing"+                               , "VaticanaStaff"+                               , "VaticanaVoice"+                               , "Voice"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&'()*+,-./0123456789:;<=>?[\\]^_{|}~"+                              }+                            (makeWordSet True [ "InnerChoirStaff" , "InnerStaffGroup" ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '.'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&'()*+,-./0123456789:;<=>?[\\]^_{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Accidental"+                               , "AccidentalCautionary"+                               , "AccidentalPlacement"+                               , "AccidentalSuggestion"+                               , "Ambitus"+                               , "AmbitusAccidental"+                               , "AmbitusLine"+                               , "AmbitusNoteHead"+                               , "Arpeggio"+                               , "BalloonTextItem"+                               , "BarLine"+                               , "BarNumber"+                               , "BassFigure"+                               , "BassFigureAlignment"+                               , "BassFigureAlignmentPositioning"+                               , "BassFigureBracket"+                               , "BassFigureContinuation"+                               , "BassFigureLine"+                               , "Beam"+                               , "BendAfter"+                               , "BreakAlignGroup"+                               , "BreakAlignment"+                               , "BreathingSign"+                               , "ChordName"+                               , "Clef"+                               , "ClusterSpanner"+                               , "ClusterSpannerBeacon"+                               , "CombineTextScript"+                               , "Custos"+                               , "DotColumn"+                               , "Dots"+                               , "DoublePercentRepeat"+                               , "DoublePercentRepeatCounter"+                               , "DynamicLineSpanner"+                               , "DynamicText"+                               , "DynamicTextSpanner"+                               , "Episema"+                               , "Fingering"+                               , "FretBoard"+                               , "Glissando"+                               , "GraceSpacing"+                               , "GridLine"+                               , "GridPoint"+                               , "Hairpin"+                               , "HarmonicParenthesesItem"+                               , "HorizontalBracket"+                               , "InstrumentName"+                               , "InstrumentSwitch"+                               , "KeyCancellation"+                               , "KeySignature"+                               , "LaissezVibrerTie"+                               , "LaissezVibrerTieColumn"+                               , "LedgerLineSpanner"+                               , "LeftEdge"+                               , "LigatureBracket"+                               , "LyricExtender"+                               , "LyricHyphen"+                               , "LyricSpace"+                               , "LyricText"+                               , "MeasureGrouping"+                               , "MelodyItem"+                               , "MensuralLigature"+                               , "MetronomeMark"+                               , "MultiMeasureRest"+                               , "MultiMeasureRestNumber"+                               , "MultiMeasureRestText"+                               , "NonMusicalPaperColumn"+                               , "NoteCollision"+                               , "NoteColumn"+                               , "NoteHead"+                               , "NoteName"+                               , "NoteSpacing"+                               , "OctavateEight"+                               , "OttavaBracket"+                               , "PaperColumn"+                               , "ParenthesesItem"+                               , "PercentRepeat"+                               , "PercentRepeatCounter"+                               , "PhrasingSlur"+                               , "PianoPedalBracket"+                               , "RehearsalMark"+                               , "RepeatSlash"+                               , "RepeatTie"+                               , "RepeatTieColumn"+                               , "Rest"+                               , "RestCollision"+                               , "Script"+                               , "ScriptColumn"+                               , "ScriptRow"+                               , "SeparationItem"+                               , "Slur"+                               , "SostenutoPedal"+                               , "SostenutoPedalLineSpanner"+                               , "SpacingSpanner"+                               , "SpanBar"+                               , "StaffGrouper"+                               , "StaffSpacing"+                               , "StaffSymbol"+                               , "StanzaNumber"+                               , "Stem"+                               , "StemTremolo"+                               , "StringNumber"+                               , "StrokeFinger"+                               , "SustainPedal"+                               , "SustainPedalLineSpanner"+                               , "System"+                               , "SystemStartBar"+                               , "SystemStartBrace"+                               , "SystemStartBracket"+                               , "SystemStartSquare"+                               , "TabNoteHead"+                               , "TextScript"+                               , "TextSpanner"+                               , "Tie"+                               , "TieColumn"+                               , "TimeSignature"+                               , "TrillPitchAccidental"+                               , "TrillPitchGroup"+                               , "TrillPitchHead"+                               , "TrillSpanner"+                               , "TupletBracket"+                               , "TupletNumber"+                               , "UnaCordaPedal"+                               , "UnaCordaPedalLineSpanner"+                               , "VaticanaLigature"+                               , "VerticalAlignment"+                               , "VerticalAxisGroup"+                               , "VoiceFollower"+                               , "VoltaBracket"+                               , "VoltaBracketSpanner"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Za-z]+(?=\\s*\\.)"+                              , reCompiled = Just (compileRegex True "[A-Za-z]+(?=\\s*\\.)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Za-z]+"+                              , reCompiled = Just (compileRegex True "[A-Za-z]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "pitch"+          , Context+              { cName = "pitch"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "=\\s*('+|,+)?"+                              , reCompiled = Just (compileRegex True "=\\s*('+|,+)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "!?"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "duration" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "scheme"+          , Context+              { cName = "scheme"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = FloatTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Push ( "LilyPond" , "scheme2" ) ]+              , cDynamic = False+              }+          )+        , ( "scheme2"+          , Context+              { cName = "scheme2"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "scheme3" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "schemerules" )+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = FloatTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "scheme3"+          , Context+              { cName = "scheme3"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "schemerules" )+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = FloatTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "schemecommentblock"+          , Context+              { cName = "schemecommentblock"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '!' '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "schemecommentline"+          , Context+              { cName = "schemecommentline"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "schemelily"+          , Context+              { cName = "schemelily"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '#' '}'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "lilypond" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "schemequote"+          , Context+              { cName = "schemequote"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b(define|defined\\?|define\\*(-public)?|define-(\\*|builtin-markup-(list-)?command|class|(extra-)?display-method|fonts?|grob-property|ly-syntax(-loc|-simple)?|macro(-public)?|markup-(list-)command|method|module|music-function|post-event-display-method|public(-macro|-toplevel)?|safe-public|span-event-display-method)|defmacro(\\*(-public)?)?|lambda\\*?|and|or|if|cond|case|let\\*?|letrec|begin|do|delay|set!|else|(quasi)?quote|unquote(-splicing)?|(define|let|letrec)-syntax|syntax-rules)(?=($|\\s|\\)))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\b(define|defined\\?|define\\*(-public)?|define-(\\*|builtin-markup-(list-)?command|class|(extra-)?display-method|fonts?|grob-property|ly-syntax(-loc|-simple)?|macro(-public)?|markup-(list-)command|method|module|music-function|post-event-display-method|public(-macro|-toplevel)?|safe-public|span-event-display-method)|defmacro(\\*(-public)?)?|lambda\\*?|and|or|if|cond|case|let\\*?|letrec|begin|do|delay|set!|else|(quasi)?quote|unquote(-splicing)?|(define|let|letrec)-syntax|syntax-rules)(?=($|\\s|\\)))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b(not|boolean\\?|eq\\?|eqv\\?|equal\\?|pair\\?|cons|set-c[ad]r!|c[ad]{1,4}r|null\\?|list\\?|list|length|append|reverse|list-ref|mem[qv]|member|ass[qv]|assoc|symbol\\?|symbol->string|string->symbol|number\\?|complex\\?|real\\?|rational\\?|integer\\?|exact\\?|inexact\\?|zero\\?|positive\\?|negative\\?|odd\\?|even\\?|max|min|abs|quotient|remainder|modulo|gcd|lcm|numerator|denominator|floor|ceiling|truncate|round|rationalize|exp|log|sin|cos|tan|asin|acos|atan|sqrt|expt|make-rectangular|make-polar|real-part|imag-part|magnitude|angle|exact->inexact|inexact->exact|number->string|string->number)(?=($|\\s|\\)))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\b(not|boolean\\?|eq\\?|eqv\\?|equal\\?|pair\\?|cons|set-c[ad]r!|c[ad]{1,4}r|null\\?|list\\?|list|length|append|reverse|list-ref|mem[qv]|member|ass[qv]|assoc|symbol\\?|symbol->string|string->symbol|number\\?|complex\\?|real\\?|rational\\?|integer\\?|exact\\?|inexact\\?|zero\\?|positive\\?|negative\\?|odd\\?|even\\?|max|min|abs|quotient|remainder|modulo|gcd|lcm|numerator|denominator|floor|ceiling|truncate|round|rationalize|exp|log|sin|cos|tan|asin|acos|atan|sqrt|expt|make-rectangular|make-polar|real-part|imag-part|magnitude|angle|exact->inexact|inexact->exact|number->string|string->number)(?=($|\\s|\\)))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b(char((-ci)?(=\\?|<\\?|>\\?|<=\\?|>=\\?)|-alphabetic\\?|\\?|-numeric\\?|-whitespace\\?|-upper-case\\?|-lower-case\\?|->integer|-upcase|-downcase|-ready\\?)|integer->char|make-string|string(\\?|-copy|-fill!|-length|-ref|-set!|(-ci)?(=\\?|<\\?|>\\?|<=\\?|>=\\?)|-append)|substring|make-vector|vector(\\?|-length|-ref|-set!|-fill!)?|procedure\\?|apply|map|for-each|force|call-with-(current-continuation|(in|out)put-file)|(in|out)put-port\\?|current-(in|out)put-port|open-(in|out)put-file|close-(in|out)put-port|eof-object\\?|read|(read|peek)-char|write(-char)?|display|newline|call/cc|list-tail|string->list|list->string|vector->list|list->vector|with-input-from-file|with-output-to-file|load|transcript-(on|off)|eval|dynamic-wind|port\\?|values|call-with-values|(scheme-report-|null-|interaction-)environment)(?=($|\\s|\\)))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\b(char((-ci)?(=\\?|<\\?|>\\?|<=\\?|>=\\?)|-alphabetic\\?|\\?|-numeric\\?|-whitespace\\?|-upper-case\\?|-lower-case\\?|->integer|-upcase|-downcase|-ready\\?)|integer->char|make-string|string(\\?|-copy|-fill!|-length|-ref|-set!|(-ci)?(=\\?|<\\?|>\\?|<=\\?|>=\\?)|-append)|substring|make-vector|vector(\\?|-length|-ref|-set!|-fill!)?|procedure\\?|apply|map|for-each|force|call-with-(current-continuation|(in|out)put-file)|(in|out)put-port\\?|current-(in|out)put-port|open-(in|out)put-file|close-(in|out)put-port|eof-object\\?|read|(read|peek)-char|write(-char)?|display|newline|call/cc|list-tail|string->list|list->string|vector->list|list->vector|with-input-from-file|with-output-to-file|load|transcript-(on|off)|eval|dynamic-wind|port\\?|values|call-with-values|(scheme-report-|null-|interaction-)environment)(?=($|\\s|\\)))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = FloatTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "schemerules"+          , Context+              { cName = "schemerules"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "schemerules" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "schemestring" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "schemecommentline" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "schemesub" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "schemequote" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '!'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "schemecommentblock" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '{'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "schemelily" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&'()*+,-./0123456789:;<=>?[\\]^_{|}~"+                              }+                            (makeWordSet+                               True+                               [ "AbsoluteDynamicEvent"+                               , "AnnotateOutputEvent"+                               , "ApplyContext"+                               , "ApplyOutputEvent"+                               , "ArpeggioEvent"+                               , "ArticulationEvent"+                               , "AutoChangeMusic"+                               , "BarCheck"+                               , "BassFigureEvent"+                               , "BeamEvent"+                               , "BeamForbidEvent"+                               , "BendAfterEvent"+                               , "BreathingEvent"+                               , "ClusterNoteEvent"+                               , "ContextChange"+                               , "ContextSpeccedMusic"+                               , "CrescendoEvent"+                               , "DecrescendoEvent"+                               , "Event"+                               , "EventChord"+                               , "ExtenderEvent"+                               , "FingeringEvent"+                               , "GlissandoEvent"+                               , "GraceMusic"+                               , "HarmonicEvent"+                               , "HyphenEvent"+                               , "KeyChangeEvent"+                               , "LabelEvent"+                               , "LaissezVibrerEvent"+                               , "LigatureEvent"+                               , "LineBreakEvent"+                               , "LyricCombineMusic"+                               , "LyricEvent"+                               , "MarkEvent"+                               , "MultiMeasureRestEvent"+                               , "MultiMeasureRestMusic"+                               , "MultiMeasureTextEvent"+                               , "Music"+                               , "NoteEvent"+                               , "NoteGroupingEvent"+                               , "OverrideProperty"+                               , "PageBreakEvent"+                               , "PageTurnEvent"+                               , "PartCombineMusic"+                               , "PercentEvent"+                               , "PercentRepeatedMusic"+                               , "PesOrFlexaEvent"+                               , "PhrasingSlurEvent"+                               , "PropertySet"+                               , "PropertyUnset"+                               , "QuoteMusic"+                               , "RelativeOctaveCheck"+                               , "RelativeOctaveMusic"+                               , "RepeatTieEvent"+                               , "RepeatedMusic"+                               , "RestEvent"+                               , "RevertProperty"+                               , "ScriptEvent"+                               , "SequentialMusic"+                               , "SimultaneousMusic"+                               , "SkipEvent"+                               , "SkipMusic"+                               , "SlurEvent"+                               , "SoloOneEvent"+                               , "SoloTwoEvent"+                               , "SostenutoEvent"+                               , "SpacingSectionEvent"+                               , "SpanEvent"+                               , "StaffSpanEvent"+                               , "StringNumberEvent"+                               , "StrokeFingerEvent"+                               , "SustainEvent"+                               , "TextScriptEvent"+                               , "TextSpanEvent"+                               , "TieEvent"+                               , "TimeScaledMusic"+                               , "TransposedMusic"+                               , "TremoloEvent"+                               , "TremoloRepeatedMusic"+                               , "TremoloSpanEvent"+                               , "TrillSpanEvent"+                               , "TupletSpanEvent"+                               , "UnaCordaEvent"+                               , "UnfoldedRepeatedMusic"+                               , "UnisonoEvent"+                               , "UnrelativableMusic"+                               , "VoiceSeparator"+                               , "VoltaRepeatedMusic"+                               ])+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&'()*+,-./0123456789:;<=>?[\\]^_{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ChoirStaff"+                               , "ChordNames"+                               , "CueVoice"+                               , "Devnull"+                               , "DrumStaff"+                               , "DrumVoice"+                               , "Dynamics"+                               , "FiguredBass"+                               , "FretBoards"+                               , "Global"+                               , "GrandStaff"+                               , "GregorianTranscriptionStaff"+                               , "GregorianTranscriptionVoice"+                               , "Lyrics"+                               , "MensuralStaff"+                               , "MensuralVoice"+                               , "NoteNames"+                               , "PianoStaff"+                               , "RhythmicStaff"+                               , "Score"+                               , "Staff"+                               , "StaffGroup"+                               , "TabStaff"+                               , "TabVoice"+                               , "Timing"+                               , "VaticanaStaff"+                               , "VaticanaVoice"+                               , "Voice"+                               ])+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&'()*+,-./0123456789:;<=>?[\\]^_{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Accidental"+                               , "AccidentalCautionary"+                               , "AccidentalPlacement"+                               , "AccidentalSuggestion"+                               , "Ambitus"+                               , "AmbitusAccidental"+                               , "AmbitusLine"+                               , "AmbitusNoteHead"+                               , "Arpeggio"+                               , "BalloonTextItem"+                               , "BarLine"+                               , "BarNumber"+                               , "BassFigure"+                               , "BassFigureAlignment"+                               , "BassFigureAlignmentPositioning"+                               , "BassFigureBracket"+                               , "BassFigureContinuation"+                               , "BassFigureLine"+                               , "Beam"+                               , "BendAfter"+                               , "BreakAlignGroup"+                               , "BreakAlignment"+                               , "BreathingSign"+                               , "ChordName"+                               , "Clef"+                               , "ClusterSpanner"+                               , "ClusterSpannerBeacon"+                               , "CombineTextScript"+                               , "Custos"+                               , "DotColumn"+                               , "Dots"+                               , "DoublePercentRepeat"+                               , "DoublePercentRepeatCounter"+                               , "DynamicLineSpanner"+                               , "DynamicText"+                               , "DynamicTextSpanner"+                               , "Episema"+                               , "Fingering"+                               , "FretBoard"+                               , "Glissando"+                               , "GraceSpacing"+                               , "GridLine"+                               , "GridPoint"+                               , "Hairpin"+                               , "HarmonicParenthesesItem"+                               , "HorizontalBracket"+                               , "InstrumentName"+                               , "InstrumentSwitch"+                               , "KeyCancellation"+                               , "KeySignature"+                               , "LaissezVibrerTie"+                               , "LaissezVibrerTieColumn"+                               , "LedgerLineSpanner"+                               , "LeftEdge"+                               , "LigatureBracket"+                               , "LyricExtender"+                               , "LyricHyphen"+                               , "LyricSpace"+                               , "LyricText"+                               , "MeasureGrouping"+                               , "MelodyItem"+                               , "MensuralLigature"+                               , "MetronomeMark"+                               , "MultiMeasureRest"+                               , "MultiMeasureRestNumber"+                               , "MultiMeasureRestText"+                               , "NonMusicalPaperColumn"+                               , "NoteCollision"+                               , "NoteColumn"+                               , "NoteHead"+                               , "NoteName"+                               , "NoteSpacing"+                               , "OctavateEight"+                               , "OttavaBracket"+                               , "PaperColumn"+                               , "ParenthesesItem"+                               , "PercentRepeat"+                               , "PercentRepeatCounter"+                               , "PhrasingSlur"+                               , "PianoPedalBracket"+                               , "RehearsalMark"+                               , "RepeatSlash"+                               , "RepeatTie"+                               , "RepeatTieColumn"+                               , "Rest"+                               , "RestCollision"+                               , "Script"+                               , "ScriptColumn"+                               , "ScriptRow"+                               , "SeparationItem"+                               , "Slur"+                               , "SostenutoPedal"+                               , "SostenutoPedalLineSpanner"+                               , "SpacingSpanner"+                               , "SpanBar"+                               , "StaffGrouper"+                               , "StaffSpacing"+                               , "StaffSymbol"+                               , "StanzaNumber"+                               , "Stem"+                               , "StemTremolo"+                               , "StringNumber"+                               , "StrokeFinger"+                               , "SustainPedal"+                               , "SustainPedalLineSpanner"+                               , "System"+                               , "SystemStartBar"+                               , "SystemStartBrace"+                               , "SystemStartBracket"+                               , "SystemStartSquare"+                               , "TabNoteHead"+                               , "TextScript"+                               , "TextSpanner"+                               , "Tie"+                               , "TieColumn"+                               , "TimeSignature"+                               , "TrillPitchAccidental"+                               , "TrillPitchGroup"+                               , "TrillPitchHead"+                               , "TrillSpanner"+                               , "TupletBracket"+                               , "TupletNumber"+                               , "UnaCordaPedal"+                               , "UnaCordaPedalLineSpanner"+                               , "VaticanaLigature"+                               , "VerticalAlignment"+                               , "VerticalAxisGroup"+                               , "VoiceFollower"+                               , "VoltaBracket"+                               , "VoltaBracketSpanner"+                               ])+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[-+]?(\\d+(\\.\\d+)?|\\.\\d+)"+                              , reCompiled =+                                  Just (compileRegex True "[-+]?(\\d+(\\.\\d+)?|\\.\\d+)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "#(t|f|b[-+]?[01.]+|o[-+]?[0-7.]+|d[-+]?[0-9.]+|x[-+]?[0-9a-f.]+)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "#(t|f|b[-+]?[01.]+|o[-+]?[0-7.]+|d[-+]?[0-9.]+|x[-+]?[0-9a-f.]+)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[+-](inf|nan)\\.0"+                              , reCompiled = Just (compileRegex True "[+-](inf|nan)\\.0")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b(define|defined\\?|define\\*(-public)?|define-(\\*|builtin-markup-(list-)?command|class|(extra-)?display-method|fonts?|grob-property|ly-syntax(-loc|-simple)?|macro(-public)?|markup-(list-)command|method|module|music-function|post-event-display-method|public(-macro|-toplevel)?|safe-public|span-event-display-method)|defmacro(\\*(-public)?)?|lambda\\*?|and|or|if|cond|case|let\\*?|letrec|begin|do|delay|set!|else|(quasi)?quote|unquote(-splicing)?|(define|let|letrec)-syntax|syntax-rules)(?=($|\\s|\\)))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\b(define|defined\\?|define\\*(-public)?|define-(\\*|builtin-markup-(list-)?command|class|(extra-)?display-method|fonts?|grob-property|ly-syntax(-loc|-simple)?|macro(-public)?|markup-(list-)command|method|module|music-function|post-event-display-method|public(-macro|-toplevel)?|safe-public|span-event-display-method)|defmacro(\\*(-public)?)?|lambda\\*?|and|or|if|cond|case|let\\*?|letrec|begin|do|delay|set!|else|(quasi)?quote|unquote(-splicing)?|(define|let|letrec)-syntax|syntax-rules)(?=($|\\s|\\)))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b(not|boolean\\?|eq\\?|eqv\\?|equal\\?|pair\\?|cons|set-c[ad]r!|c[ad]{1,4}r|null\\?|list\\?|list|length|append|reverse|list-ref|mem[qv]|member|ass[qv]|assoc|symbol\\?|symbol->string|string->symbol|number\\?|complex\\?|real\\?|rational\\?|integer\\?|exact\\?|inexact\\?|zero\\?|positive\\?|negative\\?|odd\\?|even\\?|max|min|abs|quotient|remainder|modulo|gcd|lcm|numerator|denominator|floor|ceiling|truncate|round|rationalize|exp|log|sin|cos|tan|asin|acos|atan|sqrt|expt|make-rectangular|make-polar|real-part|imag-part|magnitude|angle|exact->inexact|inexact->exact|number->string|string->number)(?=($|\\s|\\)))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\b(not|boolean\\?|eq\\?|eqv\\?|equal\\?|pair\\?|cons|set-c[ad]r!|c[ad]{1,4}r|null\\?|list\\?|list|length|append|reverse|list-ref|mem[qv]|member|ass[qv]|assoc|symbol\\?|symbol->string|string->symbol|number\\?|complex\\?|real\\?|rational\\?|integer\\?|exact\\?|inexact\\?|zero\\?|positive\\?|negative\\?|odd\\?|even\\?|max|min|abs|quotient|remainder|modulo|gcd|lcm|numerator|denominator|floor|ceiling|truncate|round|rationalize|exp|log|sin|cos|tan|asin|acos|atan|sqrt|expt|make-rectangular|make-polar|real-part|imag-part|magnitude|angle|exact->inexact|inexact->exact|number->string|string->number)(?=($|\\s|\\)))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b(char((-ci)?(=\\?|<\\?|>\\?|<=\\?|>=\\?)|-alphabetic\\?|\\?|-numeric\\?|-whitespace\\?|-upper-case\\?|-lower-case\\?|->integer|-upcase|-downcase|-ready\\?)|integer->char|make-string|string(\\?|-copy|-fill!|-length|-ref|-set!|(-ci)?(=\\?|<\\?|>\\?|<=\\?|>=\\?)|-append)|substring|make-vector|vector(\\?|-length|-ref|-set!|-fill!)?|procedure\\?|apply|map|for-each|force|call-with-(current-continuation|(in|out)put-file)|(in|out)put-port\\?|current-(in|out)put-port|open-(in|out)put-file|close-(in|out)put-port|eof-object\\?|read|(read|peek)-char|write(-char)?|display|newline|call/cc|list-tail|string->list|list->string|vector->list|list->vector|with-input-from-file|with-output-to-file|load|transcript-(on|off)|eval|dynamic-wind|port\\?|values|call-with-values|(scheme-report-|null-|interaction-)environment)(?=($|\\s|\\)))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\b(char((-ci)?(=\\?|<\\?|>\\?|<=\\?|>=\\?)|-alphabetic\\?|\\?|-numeric\\?|-whitespace\\?|-upper-case\\?|-lower-case\\?|->integer|-upcase|-downcase|-ready\\?)|integer->char|make-string|string(\\?|-copy|-fill!|-length|-ref|-set!|(-ci)?(=\\?|<\\?|>\\?|<=\\?|>=\\?)|-append)|substring|make-vector|vector(\\?|-length|-ref|-set!|-fill!)?|procedure\\?|apply|map|for-each|force|call-with-(current-continuation|(in|out)put-file)|(in|out)put-port\\?|current-(in|out)put-port|open-(in|out)put-file|close-(in|out)put-port|eof-object\\?|read|(read|peek)-char|write(-char)?|display|newline|call/cc|list-tail|string->list|list->string|vector->list|list->vector|with-input-from-file|with-output-to-file|load|transcript-(on|off)|eval|dynamic-wind|port\\?|values|call-with-values|(scheme-report-|null-|interaction-)environment)(?=($|\\s|\\)))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z#][^\\s(){}[\\];$\"]*"+                              , reCompiled =+                                  Just (compileRegex True "[a-zA-Z#][^\\s(){}[\\];$\"]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = FloatTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "schemestring"+          , Context+              { cName = "schemestring"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[0fnrtav\\\\\"]"+                              , reCompiled = Just (compileRegex True "\\\\[0fnrtav\\\\\"]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "schemesub"+          , Context+              { cName = "schemesub"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z#][^\\s(){}[\\];$\"]*"+                              , reCompiled =+                                  Just (compileRegex True "[a-zA-Z#][^\\s(){}[\\];$\"]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = DecValTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "section"+          , Context+              { cName = "section"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "section2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "section2"+          , Context+              { cName = "section2"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "sectionrules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "sectionrules"+          , Context+              { cName = "sectionrules"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "sectionrules" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&'()*+,-./0123456789:;<=>?[\\]^_{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ChoirStaff"+                               , "ChordNames"+                               , "CueVoice"+                               , "Devnull"+                               , "DrumStaff"+                               , "DrumVoice"+                               , "Dynamics"+                               , "FiguredBass"+                               , "FretBoards"+                               , "Global"+                               , "GrandStaff"+                               , "GregorianTranscriptionStaff"+                               , "GregorianTranscriptionVoice"+                               , "Lyrics"+                               , "MensuralStaff"+                               , "MensuralVoice"+                               , "NoteNames"+                               , "PianoStaff"+                               , "RhythmicStaff"+                               , "Score"+                               , "Staff"+                               , "StaffGroup"+                               , "TabStaff"+                               , "TabVoice"+                               , "Timing"+                               , "VaticanaStaff"+                               , "VaticanaVoice"+                               , "Voice"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&'()*+,-./0123456789:;<=>?[\\]^_{|}~"+                              }+                            (makeWordSet True [ "InnerChoirStaff" , "InnerStaffGroup" ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\"?)\\b((Accidental|Ambitus|Arpeggio|Auto_beam|Axis_group|Balloon|Bar|Bar_number|Beam|Bend|Break_align|Breathing_sign|Chord_name|Chord_tremolo|Clef|Cluster_spanner|Collision|Completion_heads|Custos|Default_bar_line|Dot_column|Dots|Drum_notes|Dynami_align|Dynamic|Episema|Extender|Figured_bass|Figured_bass_position|Fingering|Font_size|Forbid_line_break|Fretboard|Glissando|Grace_beam|Grace|Grace_spacing|Grid_line_span|Grid_point|Grob_pq|Hara_kiri|Horizontal_bracket)_engraver)\\b\\1"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(\"?)\\b((Accidental|Ambitus|Arpeggio|Auto_beam|Axis_group|Balloon|Bar|Bar_number|Beam|Bend|Break_align|Breathing_sign|Chord_name|Chord_tremolo|Clef|Cluster_spanner|Collision|Completion_heads|Custos|Default_bar_line|Dot_column|Dots|Drum_notes|Dynami_align|Dynamic|Episema|Extender|Figured_bass|Figured_bass_position|Fingering|Font_size|Forbid_line_break|Fretboard|Glissando|Grace_beam|Grace|Grace_spacing|Grid_line_span|Grid_point|Grob_pq|Hara_kiri|Horizontal_bracket)_engraver)\\b\\1")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\"?)\\b((Hyphen|Instrument_name|Instrument_switch|Key|Laissez_vibrer|Ledger_line|Ligature_bracket|Lyric|Mark|Measure_grouping|Melody|Mensural_ligature|Metronome_mark|Multi_measure_rest|New_dynamic|New_fingering|Note_head_line|Note_heads|Note_name|Note_spacing|Ottava_spanner|Output_property|Page_turn|Paper_column|Parenthesis|Part_combine|Percent_repeat|Phrasing_slur|Piano_pedal_align|Piano_pedal|Pitch_squash|Pitched_trill|Repeat_acknowledge|Repeat_tie|Rest_collision|Rest|Rhythmic_column|Scheme|Script_column|Script|Script_row)_engraver)\\b\\1"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(\"?)\\b((Hyphen|Instrument_name|Instrument_switch|Key|Laissez_vibrer|Ledger_line|Ligature_bracket|Lyric|Mark|Measure_grouping|Melody|Mensural_ligature|Metronome_mark|Multi_measure_rest|New_dynamic|New_fingering|Note_head_line|Note_heads|Note_name|Note_spacing|Ottava_spanner|Output_property|Page_turn|Paper_column|Parenthesis|Part_combine|Percent_repeat|Phrasing_slur|Piano_pedal_align|Piano_pedal|Pitch_squash|Pitched_trill|Repeat_acknowledge|Repeat_tie|Rest_collision|Rest|Rhythmic_column|Scheme|Script_column|Script|Script_row)_engraver)\\b\\1")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\"?)\\b((Separating_line_group|Slash_repeat|Slur|Spacing|Span_arpeggio|Span_bar|Spanner_break_forbid|Staff_collecting|Staff_symbol|Stanza_number_align|Stanza_number|Stem|String_number|Swallow|System_start_delimiter|Tab_harmonic|Tab_note_heads|Tab_staff_symbol|Text|Text_spanner|Tie|Time_signature|Trill_spanner|Tuplet|Tweak|Vaticana_ligature|Vertical_align|Vertically_spaced_contexts|Volta)_engraver)\\b\\1"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(\"?)\\b((Separating_line_group|Slash_repeat|Slur|Spacing|Span_arpeggio|Span_bar|Spanner_break_forbid|Staff_collecting|Staff_symbol|Stanza_number_align|Stanza_number|Stem|String_number|Swallow|System_start_delimiter|Tab_harmonic|Tab_note_heads|Tab_staff_symbol|Text|Text_spanner|Tie|Time_signature|Trill_spanner|Tuplet|Tweak|Vaticana_ligature|Vertical_align|Vertically_spaced_contexts|Volta)_engraver)\\b\\1")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\"?)\\b((Beam|Control_track|Drum_note|Dynamic|Key|Lyric|Note|Piano_pedal|Slur|Staff|Swallow|Tempo|Tie|Time_signature)_performer)\\b\\1"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(\"?)\\b((Beam|Control_track|Drum_note|Dynamic|Key|Lyric|Note|Piano_pedal|Slur|Staff|Swallow|Tempo|Tie|Time_signature)_performer)\\b\\1")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\"?)\\b((Note_swallow|Rest_swallow|Skip_event_swallow|Timing)_translator)\\b\\1"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(\"?)\\b((Note_swallow|Rest_swallow|Skip_event_swallow|Timing)_translator)\\b\\1")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&'()*+,-./0123456789:;<=>?[\\]^_{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Accidental"+                               , "AccidentalCautionary"+                               , "AccidentalPlacement"+                               , "AccidentalSuggestion"+                               , "Ambitus"+                               , "AmbitusAccidental"+                               , "AmbitusLine"+                               , "AmbitusNoteHead"+                               , "Arpeggio"+                               , "BalloonTextItem"+                               , "BarLine"+                               , "BarNumber"+                               , "BassFigure"+                               , "BassFigureAlignment"+                               , "BassFigureAlignmentPositioning"+                               , "BassFigureBracket"+                               , "BassFigureContinuation"+                               , "BassFigureLine"+                               , "Beam"+                               , "BendAfter"+                               , "BreakAlignGroup"+                               , "BreakAlignment"+                               , "BreathingSign"+                               , "ChordName"+                               , "Clef"+                               , "ClusterSpanner"+                               , "ClusterSpannerBeacon"+                               , "CombineTextScript"+                               , "Custos"+                               , "DotColumn"+                               , "Dots"+                               , "DoublePercentRepeat"+                               , "DoublePercentRepeatCounter"+                               , "DynamicLineSpanner"+                               , "DynamicText"+                               , "DynamicTextSpanner"+                               , "Episema"+                               , "Fingering"+                               , "FretBoard"+                               , "Glissando"+                               , "GraceSpacing"+                               , "GridLine"+                               , "GridPoint"+                               , "Hairpin"+                               , "HarmonicParenthesesItem"+                               , "HorizontalBracket"+                               , "InstrumentName"+                               , "InstrumentSwitch"+                               , "KeyCancellation"+                               , "KeySignature"+                               , "LaissezVibrerTie"+                               , "LaissezVibrerTieColumn"+                               , "LedgerLineSpanner"+                               , "LeftEdge"+                               , "LigatureBracket"+                               , "LyricExtender"+                               , "LyricHyphen"+                               , "LyricSpace"+                               , "LyricText"+                               , "MeasureGrouping"+                               , "MelodyItem"+                               , "MensuralLigature"+                               , "MetronomeMark"+                               , "MultiMeasureRest"+                               , "MultiMeasureRestNumber"+                               , "MultiMeasureRestText"+                               , "NonMusicalPaperColumn"+                               , "NoteCollision"+                               , "NoteColumn"+                               , "NoteHead"+                               , "NoteName"+                               , "NoteSpacing"+                               , "OctavateEight"+                               , "OttavaBracket"+                               , "PaperColumn"+                               , "ParenthesesItem"+                               , "PercentRepeat"+                               , "PercentRepeatCounter"+                               , "PhrasingSlur"+                               , "PianoPedalBracket"+                               , "RehearsalMark"+                               , "RepeatSlash"+                               , "RepeatTie"+                               , "RepeatTieColumn"+                               , "Rest"+                               , "RestCollision"+                               , "Script"+                               , "ScriptColumn"+                               , "ScriptRow"+                               , "SeparationItem"+                               , "Slur"+                               , "SostenutoPedal"+                               , "SostenutoPedalLineSpanner"+                               , "SpacingSpanner"+                               , "SpanBar"+                               , "StaffGrouper"+                               , "StaffSpacing"+                               , "StaffSymbol"+                               , "StanzaNumber"+                               , "Stem"+                               , "StemTremolo"+                               , "StringNumber"+                               , "StrokeFinger"+                               , "SustainPedal"+                               , "SustainPedalLineSpanner"+                               , "System"+                               , "SystemStartBar"+                               , "SystemStartBrace"+                               , "SystemStartBracket"+                               , "SystemStartSquare"+                               , "TabNoteHead"+                               , "TextScript"+                               , "TextSpanner"+                               , "Tie"+                               , "TieColumn"+                               , "TimeSignature"+                               , "TrillPitchAccidental"+                               , "TrillPitchGroup"+                               , "TrillPitchHead"+                               , "TrillSpanner"+                               , "TupletBracket"+                               , "TupletNumber"+                               , "UnaCordaPedal"+                               , "UnaCordaPedalLineSpanner"+                               , "VaticanaLigature"+                               , "VerticalAlignment"+                               , "VerticalAxisGroup"+                               , "VoiceFollower"+                               , "VoltaBracket"+                               , "VoltaBracketSpanner"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&'()*+,-./0123456789:;<=>?[\\]^_{|}~"+                              }+                            (makeWordSet+                               True+                               [ "aDueText"+                               , "alignAboveContext"+                               , "alignBassFigureAccidentals"+                               , "alignBelowContext"+                               , "allowBeamBreak"+                               , "associatedVoice"+                               , "autoAccidentals"+                               , "autoBeamCheck"+                               , "autoBeamSettings"+                               , "autoBeaming"+                               , "autoCautionaries"+                               , "automaticBars"+                               , "barAlways"+                               , "barCheckSynchronize"+                               , "barNumberVisibility"+                               , "baseMoment"+                               , "bassFigureFormatFunction"+                               , "bassStaffProperties"+                               , "beamExceptions"+                               , "beatGrouping"+                               , "beatLength"+                               , "beatStructure"+                               , "chordChanges"+                               , "chordNameExceptions"+                               , "chordNameExceptionsFull"+                               , "chordNameExceptionsPartial"+                               , "chordNameFunction"+                               , "chordNameSeparator"+                               , "chordNoteNamer"+                               , "chordPrefixSpacer"+                               , "chordRootNamer"+                               , "clefGlyph"+                               , "clefOctavation"+                               , "clefPosition"+                               , "connectArpeggios"+                               , "countPercentRepeats"+                               , "createKeyOnClefChange"+                               , "createSpacing"+                               , "crescendoSpanner"+                               , "crescendoText"+                               , "currentBarNumber"+                               , "decrescendoSpanner"+                               , "decrescendoText"+                               , "defaultBarType"+                               , "doubleRepeatType"+                               , "doubleSlurs"+                               , "drumPitchTable"+                               , "drumStyleTable"+                               , "dynamicAbsoluteVolumeFunction"+                               , "explicitClefVisibility"+                               , "explicitKeySignatureVisibility"+                               , "extendersOverRests"+                               , "extraNatural"+                               , "figuredBassAlterationDirection"+                               , "figuredBassCenterContinuations"+                               , "figuredBassFormatter"+                               , "figuredBassPlusDirection"+                               , "fingeringOrientations"+                               , "firstClef"+                               , "followVoice"+                               , "fontSize"+                               , "forbidBreak"+                               , "forceClef"+                               , "gridInterval"+                               , "hairpinToBarline"+                               , "harmonicAccidentals"+                               , "highStringOne"+                               , "ignoreBarChecks"+                               , "ignoreFiguredBassRest"+                               , "ignoreMelismata"+                               , "implicitBassFigures"+                               , "implicitTimeSignatureVisibility"+                               , "instrumentCueName"+                               , "instrumentEqualizer"+                               , "instrumentName"+                               , "instrumentTransposition"+                               , "internalBarNumber"+                               , "keepAliveInterfaces"+                               , "keyAlterationOrder"+                               , "keySignature"+                               , "lyricMelismaAlignment"+                               , "majorSevenSymbol"+                               , "markFormatter"+                               , "maximumFretStretch"+                               , "measureLength"+                               , "measurePosition"+                               , "melismaBusyProperties"+                               , "metronomeMarkFormatter"+                               , "middleCClefPosition"+                               , "middleCOffset"+                               , "middleCPosition"+                               , "midiInstrument"+                               , "midiMaximumVolume"+                               , "midiMinimumVolume"+                               , "minimumFret"+                               , "minimumPageTurnLength"+                               , "minimumRepeatLengthForPageTurn"+                               , "noteToFretFunction"+                               , "ottavation"+                               , "output"+                               , "pedalSostenutoStrings"+                               , "pedalSostenutoStyle"+                               , "pedalSustainStrings"+                               , "pedalSustainStyle"+                               , "pedalUnaCordaStrings"+                               , "pedalUnaCordaStyle"+                               , "printKeyCancellation"+                               , "printOctaveNames"+                               , "printPartCombineTexts"+                               , "proportionalNotationDuration"+                               , "recordEventSequence"+                               , "rehearsalMark"+                               , "repeatCommands"+                               , "restNumberThreshold"+                               , "scriptDefinitions"+                               , "shapeNoteStyles"+                               , "shortInstrumentName"+                               , "shortVocalName"+                               , "skipBars"+                               , "skipTypesetting"+                               , "soloIIText"+                               , "soloText"+                               , "squashedPosition"+                               , "staffLineLayoutFunction"+                               , "stanza"+                               , "stemLeftBeamCount"+                               , "stemRightBeamCount"+                               , "stringNumberOrientations"+                               , "stringOneTopmost"+                               , "stringTunings"+                               , "strokeFingerOrientations"+                               , "subdivideBeams"+                               , "suggestAccidentals"+                               , "systemStartDelimiter"+                               , "systemStartDelimiterHierarchy"+                               , "tablatureFormat"+                               , "tempoUnitCount"+                               , "tempoUnitDuration"+                               , "tempoWholesPerMinute"+                               , "tieWaitForNote"+                               , "timeSignatureFraction"+                               , "timing"+                               , "tonic"+                               , "topLevelAlignment"+                               , "trebleStaffProperties"+                               , "tremoloFlags"+                               , "tupletFullLength"+                               , "tupletFullLengthNote"+                               , "tupletSpannerDuration"+                               , "useBassFigureExtenders"+                               , "verticallySpacedContexts"+                               , "vocalName"+                               , "voltaOnThisStaff"+                               , "voltaSpannerDuration"+                               , "whichBar"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b(dedication|(sub){,2}title|poet|composer|meter|opus|arranger|instrument|piece|breakbefore|copyright|tagline|mutopia(title|composer|poet|opus|instrument)|date|enteredby|source|style|maintainer(Email|Web)?|moreInfo|lastupdated|texidoc|footer|(top|bottom|left|right)-margin|(foot|head)-separation|indent|short-indent|paper-(height|width)|horizontal-shift|line-width|(inner|outer)-margin|two-sided|binding-offset|(after|before|between)-title-space|between-system-(space|padding)|page-top-space|page-breaking-between-system-padding|(after|before|between)-title-spacing|between-(scores-)?system-spacing|bottom-system-spacing|top-title-spacing|top-system-spacing|page-breaking-between-system-spacing|system-count|(min-|max-)?systems-per-page|annotate-spacing|auto-first-page-number|blank-(last-)?page-force|first-page-number|page-count|page-limit-inter-system-space|page-limit-inter-system-space-factor|page-spacing-weight|print-all-headers|print-first-page-number|print-page-number|ragged-(bottom|right)|ragged-last(-bottom)?|system-separator-markup|force-assignment|input-encoding|output-scale|((even|odd)(Footer|Header)|(book|score|toc)Title|tocItem)Markup|system-count|(short-)?indent)\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\b(dedication|(sub){,2}title|poet|composer|meter|opus|arranger|instrument|piece|breakbefore|copyright|tagline|mutopia(title|composer|poet|opus|instrument)|date|enteredby|source|style|maintainer(Email|Web)?|moreInfo|lastupdated|texidoc|footer|(top|bottom|left|right)-margin|(foot|head)-separation|indent|short-indent|paper-(height|width)|horizontal-shift|line-width|(inner|outer)-margin|two-sided|binding-offset|(after|before|between)-title-space|between-system-(space|padding)|page-top-space|page-breaking-between-system-padding|(after|before|between)-title-spacing|between-(scores-)?system-spacing|bottom-system-spacing|top-title-spacing|top-system-spacing|page-breaking-between-system-spacing|system-count|(min-|max-)?systems-per-page|annotate-spacing|auto-first-page-number|blank-(last-)?page-force|first-page-number|page-count|page-limit-inter-system-space|page-limit-inter-system-space-factor|page-spacing-weight|print-all-headers|print-first-page-number|print-page-number|ragged-(bottom|right)|ragged-last(-bottom)?|system-separator-markup|force-assignment|input-encoding|output-scale|((even|odd)(Footer|Header)|(book|score|toc)Title|tocItem)Markup|system-count|(short-)?indent)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&'()*+,-./0123456789:;<=>?[\\]^_{|}~"+                              }+                            (makeWordSet+                               True+                               [ "barNumberAlignSymbol"+                               , "centralCPosition"+                               , "extraVerticalExtent"+                               , "fingerHorizontalDirection"+                               , "instr"+                               , "instrument"+                               , "keyAccidentalOrder"+                               , "minimumVerticalExtent"+                               , "rehearsalMarkAlignSymbol"+                               , "soloADue"+                               , "tupletNumberFormatFunction"+                               , "vocNam"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "default" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "set"+          , Context+              { cName = "set"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&'()*+,-./0123456789:;<=>?[\\]^_{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ChoirStaff"+                               , "ChordNames"+                               , "CueVoice"+                               , "Devnull"+                               , "DrumStaff"+                               , "DrumVoice"+                               , "Dynamics"+                               , "FiguredBass"+                               , "FretBoards"+                               , "Global"+                               , "GrandStaff"+                               , "GregorianTranscriptionStaff"+                               , "GregorianTranscriptionVoice"+                               , "Lyrics"+                               , "MensuralStaff"+                               , "MensuralVoice"+                               , "NoteNames"+                               , "PianoStaff"+                               , "RhythmicStaff"+                               , "Score"+                               , "Staff"+                               , "StaffGroup"+                               , "TabStaff"+                               , "TabVoice"+                               , "Timing"+                               , "VaticanaStaff"+                               , "VaticanaVoice"+                               , "Voice"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&'()*+,-./0123456789:;<=>?[\\]^_{|}~"+                              }+                            (makeWordSet True [ "InnerChoirStaff" , "InnerStaffGroup" ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '.'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&'()*+,-./0123456789:;<=>?[\\]^_{|}~"+                              }+                            (makeWordSet+                               True+                               [ "aDueText"+                               , "alignAboveContext"+                               , "alignBassFigureAccidentals"+                               , "alignBelowContext"+                               , "allowBeamBreak"+                               , "associatedVoice"+                               , "autoAccidentals"+                               , "autoBeamCheck"+                               , "autoBeamSettings"+                               , "autoBeaming"+                               , "autoCautionaries"+                               , "automaticBars"+                               , "barAlways"+                               , "barCheckSynchronize"+                               , "barNumberVisibility"+                               , "baseMoment"+                               , "bassFigureFormatFunction"+                               , "bassStaffProperties"+                               , "beamExceptions"+                               , "beatGrouping"+                               , "beatLength"+                               , "beatStructure"+                               , "chordChanges"+                               , "chordNameExceptions"+                               , "chordNameExceptionsFull"+                               , "chordNameExceptionsPartial"+                               , "chordNameFunction"+                               , "chordNameSeparator"+                               , "chordNoteNamer"+                               , "chordPrefixSpacer"+                               , "chordRootNamer"+                               , "clefGlyph"+                               , "clefOctavation"+                               , "clefPosition"+                               , "connectArpeggios"+                               , "countPercentRepeats"+                               , "createKeyOnClefChange"+                               , "createSpacing"+                               , "crescendoSpanner"+                               , "crescendoText"+                               , "currentBarNumber"+                               , "decrescendoSpanner"+                               , "decrescendoText"+                               , "defaultBarType"+                               , "doubleRepeatType"+                               , "doubleSlurs"+                               , "drumPitchTable"+                               , "drumStyleTable"+                               , "dynamicAbsoluteVolumeFunction"+                               , "explicitClefVisibility"+                               , "explicitKeySignatureVisibility"+                               , "extendersOverRests"+                               , "extraNatural"+                               , "figuredBassAlterationDirection"+                               , "figuredBassCenterContinuations"+                               , "figuredBassFormatter"+                               , "figuredBassPlusDirection"+                               , "fingeringOrientations"+                               , "firstClef"+                               , "followVoice"+                               , "fontSize"+                               , "forbidBreak"+                               , "forceClef"+                               , "gridInterval"+                               , "hairpinToBarline"+                               , "harmonicAccidentals"+                               , "highStringOne"+                               , "ignoreBarChecks"+                               , "ignoreFiguredBassRest"+                               , "ignoreMelismata"+                               , "implicitBassFigures"+                               , "implicitTimeSignatureVisibility"+                               , "instrumentCueName"+                               , "instrumentEqualizer"+                               , "instrumentName"+                               , "instrumentTransposition"+                               , "internalBarNumber"+                               , "keepAliveInterfaces"+                               , "keyAlterationOrder"+                               , "keySignature"+                               , "lyricMelismaAlignment"+                               , "majorSevenSymbol"+                               , "markFormatter"+                               , "maximumFretStretch"+                               , "measureLength"+                               , "measurePosition"+                               , "melismaBusyProperties"+                               , "metronomeMarkFormatter"+                               , "middleCClefPosition"+                               , "middleCOffset"+                               , "middleCPosition"+                               , "midiInstrument"+                               , "midiMaximumVolume"+                               , "midiMinimumVolume"+                               , "minimumFret"+                               , "minimumPageTurnLength"+                               , "minimumRepeatLengthForPageTurn"+                               , "noteToFretFunction"+                               , "ottavation"+                               , "output"+                               , "pedalSostenutoStrings"+                               , "pedalSostenutoStyle"+                               , "pedalSustainStrings"+                               , "pedalSustainStyle"+                               , "pedalUnaCordaStrings"+                               , "pedalUnaCordaStyle"+                               , "printKeyCancellation"+                               , "printOctaveNames"+                               , "printPartCombineTexts"+                               , "proportionalNotationDuration"+                               , "recordEventSequence"+                               , "rehearsalMark"+                               , "repeatCommands"+                               , "restNumberThreshold"+                               , "scriptDefinitions"+                               , "shapeNoteStyles"+                               , "shortInstrumentName"+                               , "shortVocalName"+                               , "skipBars"+                               , "skipTypesetting"+                               , "soloIIText"+                               , "soloText"+                               , "squashedPosition"+                               , "staffLineLayoutFunction"+                               , "stanza"+                               , "stemLeftBeamCount"+                               , "stemRightBeamCount"+                               , "stringNumberOrientations"+                               , "stringOneTopmost"+                               , "stringTunings"+                               , "strokeFingerOrientations"+                               , "subdivideBeams"+                               , "suggestAccidentals"+                               , "systemStartDelimiter"+                               , "systemStartDelimiterHierarchy"+                               , "tablatureFormat"+                               , "tempoUnitCount"+                               , "tempoUnitDuration"+                               , "tempoWholesPerMinute"+                               , "tieWaitForNote"+                               , "timeSignatureFraction"+                               , "timing"+                               , "tonic"+                               , "topLevelAlignment"+                               , "trebleStaffProperties"+                               , "tremoloFlags"+                               , "tupletFullLength"+                               , "tupletFullLengthNote"+                               , "tupletSpannerDuration"+                               , "useBassFigureExtenders"+                               , "verticallySpacedContexts"+                               , "vocalName"+                               , "voltaOnThisStaff"+                               , "voltaSpannerDuration"+                               , "whichBar"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&'()*+,-./0123456789:;<=>?[\\]^_{|}~"+                              }+                            (makeWordSet+                               True+                               [ "barNumberAlignSymbol"+                               , "centralCPosition"+                               , "extraVerticalExtent"+                               , "fingerHorizontalDirection"+                               , "instr"+                               , "instrument"+                               , "keyAccidentalOrder"+                               , "minimumVerticalExtent"+                               , "rehearsalMarkAlignSymbol"+                               , "soloADue"+                               , "tupletNumberFormatFunction"+                               , "vocNam"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Za-z]+"+                              , reCompiled = Just (compileRegex True "[A-Za-z]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "string"+          , Context+              { cName = "string"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "tempo"+          , Context+              { cName = "tempo"+              , cSyntax = "LilyPond"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\markup(lines)?(?![A-Za-z])"+                              , reCompiled =+                                  Just (compileRegex True "\\\\markup(lines)?(?![A-Za-z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LilyPond" , "markup" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\d+\\.*\\s*=\\s*\\d+"+                              , reCompiled = Just (compileRegex True "\\d+\\.*\\s*=\\s*\\d+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LilyPond" , "basic" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Wilbert Berendsen (info@wilbertberendsen.nl)"+  , sVersion = "4"+  , sLicense = "LGPL"+  , sExtensions =+      [ "*.ly" , "*.LY" , "*.ily" , "*.ILY" , "*.lyi" , "*.LYI" ]+  , sStartingContext = "lilypond"+  }
+ src/Skylighting/Syntax/LiterateCurry.hs view
@@ -0,0 +1,273 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.LiterateCurry (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex++syntax :: Syntax+syntax = Syntax+  { sName = "Literate Curry"+  , sFilename = "literate-curry.xml"+  , sShortname = "LiterateCurry"+  , sContexts =+      fromList+        [ ( "Code"+          , Context+              { cName = "Code"+              , cSyntax = "Literate Curry"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{-[^#]"+                              , reCompiled = Just (compileRegex True "\\{-[^#]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Literate Curry" , "multiline" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Curry" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Text"+          , Context+              { cName = "Text"+              , cSyntax = "Literate Curry"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Literate Curry" , "Code" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Literate Curry" , "Code" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "\\begin{code}"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Literate Curry" , "normals" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "\\begin{spec}"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Literate Curry" , "normals" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "lineend"+          , Context+              { cName = "lineend"+              , cSyntax = "Literate Curry"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Literate Curry" , "restart" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Literate Curry" , "restart" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "multiline"+          , Context+              { cName = "multiline"+              , cSyntax = "Literate Curry"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '-' '}'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Literate Curry" , "lineend" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "normals"+          , Context+              { cName = "normals"+              , cSyntax = "Literate Curry"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "\\end{code}"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "\\end{spec}"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Curry" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "restart"+          , Context+              { cName = "restart"+              , cSyntax = "Literate Curry"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '-' '}'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Bj\246rn Peem\246ller (bjp@informatik.uni-kiel.de)"+  , sVersion = "1"+  , sLicense = "LGPL"+  , sExtensions = [ "*.lcurry" ]+  , sStartingContext = "Text"+  }
+ src/Skylighting/Syntax/LiterateHaskell.hs view
@@ -0,0 +1,273 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.LiterateHaskell (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex++syntax :: Syntax+syntax = Syntax+  { sName = "Literate Haskell"+  , sFilename = "literate-haskell.xml"+  , sShortname = "LiterateHaskell"+  , sContexts =+      fromList+        [ ( "comments'"+          , Context+              { cName = "comments'"+              , cSyntax = "Literate Haskell"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '-' '}'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Literate Haskell" , "uncomments" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "normal"+          , Context+              { cName = "normal"+              , cSyntax = "Literate Haskell"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{-[^#]"+                              , reCompiled = Just (compileRegex True "\\{-[^#]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Literate Haskell" , "comments'" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Haskell" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "normals"+          , Context+              { cName = "normals"+              , cSyntax = "Literate Haskell"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "\\end{code}"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "\\end{spec}"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Haskell" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "recomments"+          , Context+              { cName = "recomments"+              , cSyntax = "Literate Haskell"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '-' '}'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "text"+          , Context+              { cName = "text"+              , cSyntax = "Literate Haskell"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Literate Haskell" , "normal" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Literate Haskell" , "normal" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "\\begin{code}"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Literate Haskell" , "normals" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "\\begin{spec}"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Literate Haskell" , "normals" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "uncomments"+          , Context+              { cName = "uncomments"+              , cSyntax = "Literate Haskell"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Literate Haskell" , "recomments" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Literate Haskell" , "recomments" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Nicolas Wu (zenzike@gmail.com)"+  , sVersion = "3"+  , sLicense = "LGPL"+  , sExtensions = [ "*.lhs" ]+  , sStartingContext = "text"+  }
+ src/Skylighting/Syntax/Llvm.hs view
@@ -0,0 +1,666 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Llvm (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "LLVM"+  , sFilename = "llvm.xml"+  , sShortname = "Llvm"+  , sContexts =+      fromList+        [ ( "comment"+          , Context+              { cName = "comment"+              , cSyntax = "LLVM"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "llvm"+          , Context+              { cName = "llvm"+              , cSyntax = "LLVM"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "@%"+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LLVM" , "symbol" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LLVM" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LLVM" , "string" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "i[0-9]+"+                              , reCompiled = Just (compileRegex True "i[0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[-a-zA-Z$._][-a-zA-Z$._0-9]*:"+                              , reCompiled =+                                  Just (compileRegex True "[-a-zA-Z$._][-a-zA-Z$._0-9]*:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "alias"+                               , "align"+                               , "alignstack"+                               , "asm"+                               , "begin"+                               , "blockaddress"+                               , "constant"+                               , "datalayout"+                               , "declare"+                               , "define"+                               , "end"+                               , "false"+                               , "gc"+                               , "global"+                               , "inbounds"+                               , "module"+                               , "nsw"+                               , "null"+                               , "nuw"+                               , "sideeffect"+                               , "tail"+                               , "target"+                               , "to"+                               , "triple"+                               , "true"+                               , "type"+                               , "undef"+                               , "unwind"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "appending"+                               , "available_externally"+                               , "common"+                               , "dllexport"+                               , "dllimport"+                               , "extern_weak"+                               , "internal"+                               , "linkonce"+                               , "linkonce_odr"+                               , "private"+                               , "weak"+                               , "weak_odr"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "cc" , "ccc" , "coldcc" , "fastcc" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "default" , "hidden" , "protected" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "byval"+                               , "inreg"+                               , "nest"+                               , "noalias"+                               , "nocapture"+                               , "signext"+                               , "sret"+                               , "zeroext"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "alignstack"+                               , "alwaysinline"+                               , "inlinehint"+                               , "naked"+                               , "noimplicitfloat"+                               , "noinline"+                               , "noredzone"+                               , "noreturn"+                               , "nounwind"+                               , "optnone"+                               , "optsize"+                               , "readnone"+                               , "readonly"+                               , "ssp"+                               , "sspreq"+                               , "sspstrong"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "double"+                               , "float"+                               , "fp128"+                               , "label"+                               , "metadata"+                               , "opaque"+                               , "ppc_fp128"+                               , "void"+                               , "x86_fp80"+                               , "x86mmx"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "llvm.compiler.used"+                               , "llvm.global_ctors"+                               , "llvm.global_dtors"+                               , "llvm.used"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "add"+                               , "addrspacecast"+                               , "alloca"+                               , "and"+                               , "ashr"+                               , "bitcast"+                               , "br"+                               , "call"+                               , "extractelement"+                               , "extractvalue"+                               , "fadd"+                               , "fcmp"+                               , "fdiv"+                               , "fmul"+                               , "fpext"+                               , "fptosi"+                               , "fptoui"+                               , "fptrunc"+                               , "frem"+                               , "fsub"+                               , "getelementptr"+                               , "icmp"+                               , "indirectbr"+                               , "insertelement"+                               , "insertvalue"+                               , "inttoptr"+                               , "invoke"+                               , "load"+                               , "lshr"+                               , "mul"+                               , "or"+                               , "phi"+                               , "ptrtoint"+                               , "ret"+                               , "sdiv"+                               , "select"+                               , "sext"+                               , "shl"+                               , "shufflevector"+                               , "sitofp"+                               , "srem"+                               , "store"+                               , "sub"+                               , "switch"+                               , "trunc"+                               , "udiv"+                               , "uitofp"+                               , "unreachable"+                               , "unwind"+                               , "urem"+                               , "va_arg"+                               , "xor"+                               , "zext"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "eq"+                               , "ne"+                               , "oeq"+                               , "oge"+                               , "ogt"+                               , "ole"+                               , "olt"+                               , "one"+                               , "ord"+                               , "sge"+                               , "sgt"+                               , "sle"+                               , "slt"+                               , "ueq"+                               , "uge"+                               , "ugt"+                               , "ule"+                               , "ult"+                               , "une"+                               , "uno"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "string"+          , Context+              { cName = "string"+              , cSyntax = "LLVM"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "symbol"+          , Context+              { cName = "symbol"+              , cSyntax = "LLVM"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "LLVM" , "symbol-string" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([-a-zA-Z$._][-a-zA-Z$._0-9]*|[0-9]+)"+                              , reCompiled =+                                  Just (compileRegex True "([-a-zA-Z$._][-a-zA-Z$._0-9]*|[0-9]+)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "symbol-string"+          , Context+              { cName = "symbol-string"+              , cSyntax = "LLVM"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "LLVM Team"+  , sVersion = "1.00"+  , sLicense = "LLVM Release License"+  , sExtensions = [ "*.ll" ]+  , sStartingContext = "llvm"+  }
+ src/Skylighting/Syntax/Lua.hs view
@@ -0,0 +1,1065 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Lua (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Lua"+  , sFilename = "lua.xml"+  , sShortname = "Lua"+  , sContexts =+      fromList+        [ ( "Block Comment"+          , Context+              { cName = "Block Comment"+              , cSyntax = "Lua"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\]%1\\]"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '-' '-'+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "FIXME" , "NOTE" , "TODO" ])+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "Lua"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '-' '-'+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "FIXME" , "NOTE" , "TODO" ])+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Error"+          , Context+              { cName = "Error"+              , cSyntax = "Lua"+              , cRules = []+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Lua"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "DoxygenLua" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "foreach" , "foreachi" , "table.foreach" , "table.foreachi" ])+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "--\\[(=*)\\["+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Lua" , "Block Comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '-' '-'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Lua" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[(=*)\\["+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Lua" , "String_block" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Lua" , "String_single" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Lua" , "String_double" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "LUA_PATH"+                               , "_ALERT"+                               , "_ERRORMESSAGE"+                               , "_LOADED"+                               , "_VERSION"+                               , "abs"+                               , "acos"+                               , "appendto"+                               , "ascii"+                               , "asin"+                               , "assert"+                               , "atan"+                               , "atan2"+                               , "call"+                               , "ceil"+                               , "cgilua"+                               , "cgilua.addclosefunction"+                               , "cgilua.addopenfunction"+                               , "cgilua.addscripthandler"+                               , "cgilua.buildprocesshandler"+                               , "cgilua.contentheader"+                               , "cgilua.cookies"+                               , "cgilua.cookies.delete"+                               , "cgilua.cookies.get"+                               , "cgilua.cookies.set"+                               , "cgilua.cookies.sethtml"+                               , "cgilua.doif"+                               , "cgilua.doscript"+                               , "cgilua.errorlog"+                               , "cgilua.handlelp"+                               , "cgilua.header"+                               , "cgilua.htmlheader"+                               , "cgilua.lp.compile"+                               , "cgilua.lp.include"+                               , "cgilua.lp.setcompatmode"+                               , "cgilua.lp.setoutfunc"+                               , "cgilua.lp.translate"+                               , "cgilua.mkabsoluteurl"+                               , "cgilua.mkurlpath"+                               , "cgilua.pack"+                               , "cgilua.put"+                               , "cgilua.redirect"+                               , "cgilua.script_file"+                               , "cgilua.script_path"+                               , "cgilua.script_pdir"+                               , "cgilua.script_vdir"+                               , "cgilua.script_vpath"+                               , "cgilua.serialize"+                               , "cgilua.servervariable"+                               , "cgilua.session"+                               , "cgilua.session.close"+                               , "cgilua.session.data"+                               , "cgilua.session.delete"+                               , "cgilua.session.load"+                               , "cgilua.session.new"+                               , "cgilua.session.open"+                               , "cgilua.session.save"+                               , "cgilua.session.setsessiondir"+                               , "cgilua.seterrorhandler"+                               , "cgilua.seterroroutput"+                               , "cgilua.setmaxfilesize"+                               , "cgilua.setmaxinput"+                               , "cgilua.setoutfunc"+                               , "cgilua.splitpath"+                               , "cgilua.urlcode.encodetable"+                               , "cgilua.urlcode.escape"+                               , "cgilua.urlcode.insertfield"+                               , "cgilua.urlcode.parsequery"+                               , "cgilua.urlcode.unescape"+                               , "cgilua.urlpath"+                               , "clock"+                               , "close"+                               , "closefile"+                               , "collectgarbage"+                               , "commit"+                               , "connect"+                               , "copytagmethods"+                               , "cos"+                               , "date"+                               , "debug.gethook"+                               , "debug.getinfo"+                               , "debug.getlocal"+                               , "debug.sethook"+                               , "debug.setlocal"+                               , "deg"+                               , "dofile"+                               , "dostring"+                               , "error"+                               , "execute"+                               , "exit"+                               , "exp"+                               , "fetch"+                               , "files"+                               , "floor"+                               , "flush"+                               , "foreach"+                               , "foreachi"+                               , "format"+                               , "frexp"+                               , "gcinfo"+                               , "getcolnames"+                               , "getcoltypes"+                               , "getenv"+                               , "getglobal"+                               , "getglobals"+                               , "getinfo"+                               , "getlocal"+                               , "getmetatable"+                               , "getn"+                               , "gettagmethod"+                               , "globals"+                               , "gsub"+                               , "io.close"+                               , "io.flush"+                               , "io.input"+                               , "io.lines"+                               , "io.open"+                               , "io.output"+                               , "io.read"+                               , "io.stderr"+                               , "io.stdin"+                               , "io.stdout"+                               , "io.tmpfile"+                               , "io.write"+                               , "ipairs"+                               , "ldexp"+                               , "lfs"+                               , "lfs.attributes"+                               , "lfs.chdir"+                               , "lfs.currentdir"+                               , "lfs.dir"+                               , "lfs.lock"+                               , "lfs.mkdir"+                               , "lfs.rmdir"+                               , "lfs.touch"+                               , "lfs.unlock"+                               , "lines"+                               , "loadfile"+                               , "loadstring"+                               , "log"+                               , "log10"+                               , "math.abs"+                               , "math.acos"+                               , "math.asin"+                               , "math.atan"+                               , "math.atan2"+                               , "math.ceil"+                               , "math.cos"+                               , "math.deg"+                               , "math.exp"+                               , "math.floor"+                               , "math.frexp"+                               , "math.ldexp"+                               , "math.log"+                               , "math.log10"+                               , "math.max"+                               , "math.min"+                               , "math.mod"+                               , "math.rad"+                               , "math.random"+                               , "math.randomseed"+                               , "math.sin"+                               , "math.squrt"+                               , "math.tan"+                               , "max"+                               , "min"+                               , "mod"+                               , "newtag"+                               , "next"+                               , "numrows"+                               , "openfile"+                               , "os.clock"+                               , "os.date"+                               , "os.difftime"+                               , "os.execute"+                               , "os.exit"+                               , "os.getenv"+                               , "os.remove"+                               , "os.rename"+                               , "os.setlocale"+                               , "os.time"+                               , "os.tmpname"+                               , "pairs"+                               , "pcall"+                               , "print"+                               , "rad"+                               , "random"+                               , "randomseed"+                               , "rawget"+                               , "rawset"+                               , "read"+                               , "readfrom"+                               , "remove"+                               , "rename"+                               , "require"+                               , "rollback"+                               , "seek"+                               , "setautocommit"+                               , "setcallhook"+                               , "setglobal"+                               , "setglobals"+                               , "setlinehook"+                               , "setlocal"+                               , "setlocale"+                               , "setmetatable"+                               , "settag"+                               , "settagmethod"+                               , "sin"+                               , "sort"+                               , "squrt"+                               , "strbyte"+                               , "strchar"+                               , "strfind"+                               , "string.byte"+                               , "string.char"+                               , "string.find"+                               , "string.format"+                               , "string.gfind"+                               , "string.gsub"+                               , "string.len"+                               , "string.lower"+                               , "string.rep"+                               , "string.sub"+                               , "string.upper"+                               , "strlen"+                               , "strlower"+                               , "strrep"+                               , "strsub"+                               , "strupper"+                               , "table.concat"+                               , "table.foreach"+                               , "table.foreachi"+                               , "table.getn"+                               , "table.insert"+                               , "table.remove"+                               , "table.setn"+                               , "table.sort"+                               , "tag"+                               , "tan"+                               , "tinsert"+                               , "tmpname"+                               , "tonumber"+                               , "tostring"+                               , "tremove"+                               , "type"+                               , "unpack"+                               , "write"+                               , "writeto"+                               , "zip"+                               , "zip.open"+                               , "zip.openfile"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bfunction\\b"+                              , reCompiled = Just (compileRegex True "\\bfunction\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True [ "and" , "function" , "in" , "local" , "not" , "or" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "false" , "nil" , "true" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\belse\\b"+                              , reCompiled = Just (compileRegex True "\\belse\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\belseif\\b"+                              , reCompiled = Just (compileRegex True "\\belseif\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bdo\\b"+                              , reCompiled = Just (compileRegex True "\\bdo\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bif\\b"+                              , reCompiled = Just (compileRegex True "\\bif\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bend\\b"+                              , reCompiled = Just (compileRegex True "\\bend\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "break"+                               , "do"+                               , "else"+                               , "elseif"+                               , "end"+                               , "for"+                               , "if"+                               , "repeat"+                               , "return"+                               , "then"+                               , "until"+                               , "while"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b\\d*\\.?\\d*(e|e\\-|e\\+)?\\d+\\b"+                              , reCompiled =+                                  Just (compileRegex True "\\b\\d*\\.?\\d*(e|e\\-|e\\+)?\\d+\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b-?0[xX][0-9a-fA-F]+\\b"+                              , reCompiled = Just (compileRegex True "\\b-?0[xX][0-9a-fA-F]+\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[a-zA-Z_][a-zA-Z0-9_]*(?=\\s*([({'\"]|\\[\\[))\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\b[a-zA-Z_][a-zA-Z0-9_]*(?=\\s*([({'\"]|\\[\\[))\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[A-Z_][A-Z0-9_]*\\b"+                              , reCompiled = Just (compileRegex True "\\b[A-Z_][A-Z0-9_]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[a-zA-Z_][a-zA-Z0-9_]*\\b"+                              , reCompiled =+                                  Just (compileRegex True "\\b[a-zA-Z_][a-zA-Z0-9_]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '!' '='+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '-' '='+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '+' '='+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '+' '+'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '.' '='+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "[]().,=~+-*/^><#;"+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String_block"+          , Context+              { cName = "String_block"+              , cSyntax = "Lua"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(a|b|f|n|r|t|v|\\\\|\"|\\'|[|])"+                              , reCompiled =+                                  Just (compileRegex True "\\\\(a|b|f|n|r|t|v|\\\\|\"|\\'|[|])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\]%1\\]"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "String_double"+          , Context+              { cName = "String_double"+              , cSyntax = "Lua"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[abfnrtv'\"\\\\\\[\\]]"+                              , reCompiled =+                                  Just (compileRegex True "\\\\[abfnrtv'\"\\\\\\[\\]]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Lua" , "Error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String_single"+          , Context+              { cName = "String_single"+              , cSyntax = "Lua"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(a|b|f|n|r|t|v|\\\\|\"|\\'|[|])"+                              , reCompiled =+                                  Just (compileRegex True "\\\\(a|b|f|n|r|t|v|\\\\|\"|\\'|[|])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Lua" , "Error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = ""+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.lua" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/M4.hs view
@@ -0,0 +1,382 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.M4 (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "GNU M4"+  , sFilename = "m4.xml"+  , sShortname = "M4"+  , sContexts =+      fromList+        [ ( "Normal Text"+          , Context+              { cName = "Normal Text"+              , cSyntax = "GNU M4"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "__file__"+                               , "__line__"+                               , "__program__"+                               , "builtin"+                               , "changecom"+                               , "changequote"+                               , "changeword"+                               , "debugfile"+                               , "debugmode"+                               , "decr"+                               , "define"+                               , "defn"+                               , "divert"+                               , "divnum"+                               , "dnl"+                               , "dumpdef"+                               , "errprint"+                               , "esyscmd"+                               , "eval"+                               , "format"+                               , "ifdef"+                               , "ifelse"+                               , "include"+                               , "incr"+                               , "index"+                               , "indir"+                               , "len"+                               , "m4exit"+                               , "m4wrap"+                               , "maketemp"+                               , "mkstemp"+                               , "patsubst"+                               , "popdef"+                               , "pushdef"+                               , "regexp"+                               , "shift"+                               , "sinclude"+                               , "substr"+                               , "syscmd"+                               , "sysval"+                               , "traceoff"+                               , "traceon"+                               , "translit"+                               , "undefine"+                               , "undivert"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "m4___file__"+                               , "m4___line__"+                               , "m4___program__"+                               , "m4_builtin"+                               , "m4_changecom"+                               , "m4_changequote"+                               , "m4_changeword"+                               , "m4_debugfile"+                               , "m4_debugmode"+                               , "m4_decr"+                               , "m4_define"+                               , "m4_defn"+                               , "m4_divert"+                               , "m4_divnum"+                               , "m4_dnl"+                               , "m4_dumpdef"+                               , "m4_errprint"+                               , "m4_esyscmd"+                               , "m4_eval"+                               , "m4_format"+                               , "m4_ifdef"+                               , "m4_ifelse"+                               , "m4_include"+                               , "m4_incr"+                               , "m4_index"+                               , "m4_indir"+                               , "m4_len"+                               , "m4_m4exit"+                               , "m4_m4wrap"+                               , "m4_maketemp"+                               , "m4_mkstemp"+                               , "m4_patsubst"+                               , "m4_popdef"+                               , "m4_pushdef"+                               , "m4_regexp"+                               , "m4_shift"+                               , "m4_sinclude"+                               , "m4_substr"+                               , "m4_syscmd"+                               , "m4_sysval"+                               , "m4_traceoff"+                               , "m4_traceon"+                               , "m4_translit"+                               , "m4_undefine"+                               , "m4_undivert"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "__gnu__"+                               , "__os2__"+                               , "__unix__"+                               , "__windows__"+                               , "os2"+                               , "unix"+                               , "windows"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "m4___gnu__"+                               , "m4___os2__"+                               , "m4___unix__"+                               , "m4___windows__"+                               , "m4_os2"+                               , "m4_unix"+                               , "m4_windows"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z_]\\w+"+                              , reCompiled = Just (compileRegex True "[a-zA-Z_]\\w+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$([1-9]\\d*|0|\\#|\\*|\\@|\\{([1-9]\\d*|0)\\})"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\$([1-9]\\d*|0|\\#|\\*|\\@|\\{([1-9]\\d*|0)\\})")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([1-9]\\d*|0|0x[0-9abcdefABCDEF]+)"+                              , reCompiled =+                                  Just (compileRegex True "([1-9]\\d*|0|0x[0-9abcdefABCDEF]+)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#.*$"+                              , reCompiled = Just (compileRegex True "#.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "GNU M4" , "inparenthesis" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[+*/%\\|=\\!<>!^&~-]"+                              , reCompiled = Just (compileRegex True "[+*/%\\|=\\!<>!^&~-]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "inparenthesis"+          , Context+              { cName = "inparenthesis"+              , cSyntax = "GNU M4"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "GNU M4" , "Normal Text" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Jaak Ristioja"+  , sVersion = "2"+  , sLicense = "New BSD License"+  , sExtensions = [ "*.m4" ]+  , sStartingContext = "Normal Text"+  }
+ src/Skylighting/Syntax/Makefile.hs view
@@ -0,0 +1,2654 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Makefile (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Makefile"+  , sFilename = "makefile.xml"+  , sShortname = "Makefile"+  , sContexts =+      fromList+        [ ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Modelines" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "assign"+          , Context+              { cName = "assign"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "value" ) ]+                      }+                  ]+              , cAttribute = CharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "bmake_conditional"+          , Context+              { cName = "bmake_conditional"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Makefile" , "strings_and_vars" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True [ "commands" , "defined" , "empty" , "exists" , "target" ])+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "bmake_expression" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '&' '&'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '|' '|'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '!' '='+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '=' '='+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '!'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = LineContinue+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "bmake_expression"+          , Context+              { cName = "bmake_expression"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Makefile" , "strings_and_vars" )+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "bmake_for_loop"+          , Context+              { cName = "bmake_for_loop"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Makefile" , "strings_and_vars" )+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = WordDetect "in"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "bmake_include"+          , Context+              { cName = "bmake_include"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = RangeDetect '<' '>'+                      , rAttribute = ImportTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = RangeDetect '"' '"'+                      , rAttribute = ImportTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "bmake_message"+          , Context+              { cName = "bmake_message"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "dollar" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "bmake_other_stmts"+          , Context+              { cName = "bmake_other_stmts"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Makefile" , "strings_and_vars" )+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "bmake_special_target"+          , Context+              { cName = "bmake_special_target"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Makefile" , "prereq" ) ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Makefile" , "rule" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "bmake_var_modifier"+          , Context+              { cName = "bmake_var_modifier"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "dollar" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "EHOQRTuLP"+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Makefile" , "expect}" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars 's' 'h'+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Makefile" , "expect}" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars 'O' 'x'+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Makefile" , "expect}" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars 't' 'A'+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Makefile" , "expect}" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars 't' 'L'+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Makefile" , "expect}" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "gmtime"+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Makefile" , "expect}" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "hash"+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Makefile" , "expect}" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "localtime"+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Makefile" , "expect}" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "MNDU"+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Pop , Push ( "Makefile" , "bmake_var_modifier_arg" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "SC"+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Pop , Push ( "Makefile" , "bmake_var_modifier_arg" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars ':' '='+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Pop , Push ( "Makefile" , "bmake_var_modifier_arg" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect ":?="+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Pop , Push ( "Makefile" , "bmake_var_modifier_arg" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect ":+="+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Pop , Push ( "Makefile" , "bmake_var_modifier_arg" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect ":!="+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Pop , Push ( "Makefile" , "bmake_var_modifier_arg" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars 't' 'u'+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Pop , Push ( "Makefile" , "bmake_var_modifier_arg" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars 't' 'W'+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Pop , Push ( "Makefile" , "bmake_var_modifier_arg" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars 't' 'w'+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Pop , Push ( "Makefile" , "bmake_var_modifier_arg" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars 't' 's'+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Pop , Push ( "Makefile" , "bmake_var_modifier_arg" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ""+                              , reCompiled = Just (compileRegex True "")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Makefile" , "bmake_var_modifier_arg" )+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext =+                  [ Pop , Push ( "Makefile" , "bmake_var_modifier_arg" ) ]+              , cDynamic = False+              }+          )+        , ( "bmake_var_modifier_arg"+          , Context+              { cName = "bmake_var_modifier_arg"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "dollar" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '}'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ':'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Pop , Push ( "Makefile" , "bmake_var_modifier" ) ]+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "call("+          , Context+              { cName = "call("+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "abspath"+                               , "addprefix"+                               , "addsuffix"+                               , "and"+                               , "basename"+                               , "call"+                               , "dir"+                               , "error"+                               , "eval"+                               , "filter"+                               , "filter-out"+                               , "findstring"+                               , "firstword"+                               , "flavor"+                               , "foreach"+                               , "if"+                               , "info"+                               , "join"+                               , "lastword"+                               , "notdir"+                               , "or"+                               , "origin"+                               , "patsubst"+                               , "realpath"+                               , "shell"+                               , "sort"+                               , "strip"+                               , "subst"+                               , "suffix"+                               , "value"+                               , "warning"+                               , "wildcard"+                               , "word"+                               , "wordlist"+                               , "words"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "callFunc(" ) ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Push ( "Makefile" , "callVar(" ) ]+              , cDynamic = False+              }+          )+        , ( "callFunc("+          , Context+              { cName = "callFunc("+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "dollar" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "string'" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "callFunc{"+          , Context+              { cName = "callFunc{"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "dollar" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "string'" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "callVar("+          , Context+              { cName = "callVar("+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "dollar" ) ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "=#:"+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "callVar{"+          , Context+              { cName = "callVar{"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "dollar" ) ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ':'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Makefile" , "expect}" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Pop , Push ( "Makefile" , "bmake_var_modifier_arg" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "bmake_var_modifier" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "=#"+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "call{"+          , Context+              { cName = "call{"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "abspath"+                               , "addprefix"+                               , "addsuffix"+                               , "and"+                               , "basename"+                               , "call"+                               , "dir"+                               , "error"+                               , "eval"+                               , "filter"+                               , "filter-out"+                               , "findstring"+                               , "firstword"+                               , "flavor"+                               , "foreach"+                               , "if"+                               , "info"+                               , "join"+                               , "lastword"+                               , "notdir"+                               , "or"+                               , "origin"+                               , "patsubst"+                               , "realpath"+                               , "shell"+                               , "sort"+                               , "strip"+                               , "subst"+                               , "suffix"+                               , "value"+                               , "warning"+                               , "wildcard"+                               , "word"+                               , "wordlist"+                               , "words"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "callFunc{" ) ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Push ( "Makefile" , "callVar{" ) ]+              , cDynamic = False+              }+          )+        , ( "dollar"+          , Context+              { cName = "dollar"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "call(" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "call{" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "expect}"+          , Context+              { cName = "expect}"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '}'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop , Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gmake_else"+          , Context+              { cName = "gmake_else"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "if" , "ifdef" , "ifeq" , "ifndef" , "ifneq" ])+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Makefile" , "strings_and_vars" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "normal"+          , Context+              { cName = "normal"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True [ ".if" , ".ifdef" , ".ifmake" , ".ifndef" , ".ifnmake" ])+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "bmake_conditional" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ ".elif"+                               , ".elifdef"+                               , ".elifmake"+                               , ".elifndef"+                               , ".elifnmake"+                               , ".else"+                               ])+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "bmake_conditional" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ ".endif" ])+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "if" , "ifdef" , "ifeq" , "ifndef" , "ifneq" ])+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "else" ])+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "gmake_else" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "endif" ])+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "-include" , "define" , "endef" , "include" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ ".export"+                               , ".export-env"+                               , ".undef"+                               , ".unexport"+                               , ".unexport-env"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "bmake_other_stmts" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^\\s:?]*\\s*(?=:=|=|\\+=|\\?=)"+                              , reCompiled =+                                  Just (compileRegex True "[^\\s:?]*\\s*(?=:=|=|\\+=|\\?=)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "assign" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ ".BEGIN"+                               , ".DEFAULT"+                               , ".END"+                               , ".ERROR"+                               , ".IGNORE"+                               , ".INTERRUPT"+                               , ".MAIN"+                               , ".MAKEFLAGS"+                               , ".NOPATH"+                               , ".NOTPARALLEL"+                               , ".NO_PARALLEL"+                               , ".OBJDIR"+                               , ".ORDER"+                               , ".PATH"+                               , ".PHONY"+                               , ".PRECIOUS"+                               , ".SHELL"+                               , ".SILENT"+                               , ".STALE"+                               , ".SUFFIXES"+                               ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "bmake_special_target" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.PATH\\.[^:]*:"+                              , reCompiled = Just (compileRegex True "\\.PATH\\.[^:]*:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "prereq" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ ".-include" , ".include" , ".sinclude" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "bmake_include" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ ".error" , ".info" , ".warning" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "bmake_message" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ ".for" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "bmake_for_loop" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ ".endfor" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.[^.][^:]*:"+                              , reCompiled = Just (compileRegex True "\\.[^.][^:]*:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Makefile" , "prereq" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^:]*:"+                              , reCompiled = Just (compileRegex True "[^:]*:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Makefile" , "prereq" ) ]+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "string\"" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "string'" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "dollar" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '#'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "@-"+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "silent" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "prereq"+          , Context+              { cName = "prereq"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ ".EXEC"+                               , ".IGNORE"+                               , ".MADE"+                               , ".MAKE"+                               , ".META"+                               , ".NOMETA"+                               , ".NOMETA_CMP"+                               , ".NOPATH"+                               , ".NOTMAIN"+                               , ".OPTIONAL"+                               , ".PHONY"+                               , ".PRECIOUS"+                               , ".RECURSIVE"+                               , ".SILENT"+                               , ".USE"+                               , ".USEBEFORE"+                               , ".WAIT"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = LineContinue+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "dollar" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '#'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "Comment" ) ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Makefile" , "rule" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "rule"+          , Context+              { cName = "rule"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = " +"+                              , reCompiled = Just (compileRegex True " +")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^\\t]"+                              , reCompiled = Just (compileRegex True "[^\\t]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = True+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "string\"" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "string'" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "dollar" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '#'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "@-"+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "silent" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "Comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "silent"+          , Context+              { cName = "silent"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "string\"" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "string'" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "dollar" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '#'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "Comment" ) ]+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "string\""+          , Context+              { cName = "string\""+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "dollar" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "string'"+          , Context+              { cName = "string'"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "dollar" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "strings_and_vars"+          , Context+              { cName = "strings_and_vars"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "dollar" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "string\"" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "string'" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "Comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "value"+          , Context+              { cName = "value"+              , cSyntax = "Makefile"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Makefile" , "dollar" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@[-_\\d\\w]*@"+                              , reCompiled = Just (compileRegex True "@[-_\\d\\w]*@")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Per Wigren (wigren@home.se)"+  , sVersion = "4"+  , sLicense = ""+  , sExtensions =+      [ "GNUmakefile"+      , "Makefile"+      , "makefile"+      , "GNUmakefile.*"+      , "Makefile.*"+      , "makefile.*"+      , "*.mk"+      ]+  , sStartingContext = "normal"+  }
+ src/Skylighting/Syntax/Mandoc.hs view
@@ -0,0 +1,228 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Mandoc (syntax) where++import Skylighting.Types+import Data.Map+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Troff Mandoc"+  , sFilename = "mandoc.xml"+  , sShortname = "Mandoc"+  , sContexts =+      fromList+        [ ( "DetectDirective"+          , Context+              { cName = "DetectDirective"+              , cSyntax = "Troff Mandoc"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "SH" , "SS" , "TH" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Troff Mandoc" , "Directive" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "HP" , "IP" , "LP" , "P" , "PD" , "PP" , "RE" , "RS" , "TP" ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Troff Mandoc" , "Directive" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "B"+                               , "BI"+                               , "BR"+                               , "I"+                               , "IB"+                               , "IR"+                               , "RB"+                               , "RI"+                               , "SB"+                               , "SM"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Troff Mandoc" , "Directive" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "DT" ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Troff Mandoc" , "Directive" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Roff" , "DetectDirective" )+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Directive"+          , Context+              { cName = "Directive"+              , cSyntax = "Troff Mandoc"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Roff" , "Directive" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Troff Mandoc"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Roff" , "DetectComments" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '.'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Troff Mandoc" , "DetectDirective" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Roff" , "DetectOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Matthew Woehlke (mw_triad@users.sourceforge.net)"+  , sVersion = "1"+  , sLicense = "GPL"+  , sExtensions =+      [ "*.1"+      , "*.2"+      , "*.3"+      , "*.4"+      , "*.5"+      , "*.6"+      , "*.7"+      , "*.8"+      , "*.1m"+      , "*.3x"+      , "*.tmac"+      ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Markdown.hs view
@@ -0,0 +1,835 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Markdown (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex++syntax :: Syntax+syntax = Syntax+  { sName = "Markdown"+  , sFilename = "markdown.xml"+  , sShortname = "Markdown"+  , sContexts =+      fromList+        [ ( "Normal Text"+          , Context+              { cName = "Normal Text"+              , cSyntax = "Markdown"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Markdown" , "blockquote" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s.*[#]?$"+                              , reCompiled = Just (compileRegex True "#\\s.*[#]?$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "##\\s.*[#]?$"+                              , reCompiled = Just (compileRegex True "##\\s.*[#]?$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "###\\s.*[#]?$"+                              , reCompiled = Just (compileRegex True "###\\s.*[#]?$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "####\\s.*[#]?$"+                              , reCompiled = Just (compileRegex True "####\\s.*[#]?$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#####\\s.*[#]?$"+                              , reCompiled = Just (compileRegex True "#####\\s.*[#]?$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "######\\s.*[#]?$"+                              , reCompiled = Just (compileRegex True "######\\s.*[#]?$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*([\\*\\-_]\\s?){3,}\\s*"+                              , reCompiled =+                                  Just (compileRegex True "\\s*([\\*\\-_]\\s?){3,}\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\s|^)[\\*_]{2}[^\\s]{1}[^\\*_]+[\\*_]{2}(\\s|\\.|,|;|:|\\-|\\?|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(\\s|^)[\\*_]{2}[^\\s]{1}[^\\*_]+[\\*_]{2}(\\s|\\.|,|;|:|\\-|\\?|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\s|^)[\\*_]{1}[^\\s]{1}[^\\*_]+[\\*_]{1}(\\s|\\.|,|;|:|\\-|\\?|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(\\s|^)[\\*_]{1}[^\\s]{1}[^\\*_]+[\\*_]{1}(\\s|\\.|,|;|:|\\-|\\?|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\s|^)[\\*_]{3}[^\\*_]+[\\*_]{3}(\\s|\\.|,|;|:|\\-|\\?|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(\\s|^)[\\*_]{3}[^\\*_]+[\\*_]{3}(\\s|\\.|,|;|:|\\-|\\?|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([\\s]{4,}|\\t+).*$"+                              , reCompiled = Just (compileRegex True "([\\s]{4,}|\\t+).*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\*\\+\\-]\\s"+                              , reCompiled = Just (compileRegex True "[\\*\\+\\-]\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Markdown" , "bullet" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\d]+\\.\\s"+                              , reCompiled = Just (compileRegex True "[\\d]+\\.\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Markdown" , "numlist" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(Title|Author|Date|Copyright|Revision|CSS|LaTeX\\ XSLT|Categories|Tags|BaseName|Excerpt):(.*)+$"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(Title|Author|Date|Copyright|Revision|CSS|LaTeX\\ XSLT|Categories|Tags|BaseName|Excerpt):(.*)+$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Markdown" , "inc" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "blockquote"+          , Context+              { cName = "blockquote"+              , cSyntax = "Markdown"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\s|^)[\\*_]{2}[^\\s]{1}[^\\*_]+[\\*_]{2}(\\s|\\.|,|;|:|\\-|\\?|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(\\s|^)[\\*_]{2}[^\\s]{1}[^\\*_]+[\\*_]{2}(\\s|\\.|,|;|:|\\-|\\?|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\s|^)[\\*_]{1}[^\\s]{1}[^\\*_]+[\\*_]{1}(\\s|\\.|,|;|:|\\-|\\?|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(\\s|^)[\\*_]{1}[^\\s]{1}[^\\*_]+[\\*_]{1}(\\s|\\.|,|;|:|\\-|\\?|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Markdown" , "inc" )+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = [ Pop ]+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "bullet"+          , Context+              { cName = "bullet"+              , cSyntax = "Markdown"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\s|^)[\\*_]{2}[^\\s]{1}[^\\*_]+[\\*_]{2}(\\s|\\.|,|;|:|\\-|\\?|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(\\s|^)[\\*_]{2}[^\\s]{1}[^\\*_]+[\\*_]{2}(\\s|\\.|,|;|:|\\-|\\?|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\s|^)[\\*_]{1}[^\\s]{1}[^\\*_]+[\\*_]{1}(\\s|\\.|,|;|:|\\-|\\?|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(\\s|^)[\\*_]{1}[^\\s]{1}[^\\*_]+[\\*_]{1}(\\s|\\.|,|;|:|\\-|\\?|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Markdown" , "inc" )+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = FloatTok+              , cLineEmptyContext = [ Pop ]+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "comment"+          , Context+              { cName = "comment"+              , cSyntax = "Markdown"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-->"+                              , reCompiled = Just (compileRegex True "-->")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "inc"+          , Context+              { cName = "inc"+              , cSyntax = "Markdown"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "`[^`]+`"+                              , reCompiled = Just (compileRegex True "`[^`]+`")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<!--"+                              , reCompiled = Just (compileRegex True "<!--")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Markdown" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\[[^\\]\\^]+\\]\\s*\\[[^\\]]*\\]\\s*(\\s+\\\"[^\\\"]*\\\"){0,1}"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\[[^\\]\\^]+\\]\\s*\\[[^\\]]*\\]\\s*(\\s+\\\"[^\\\"]*\\\"){0,1}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[\\^[^\\]]+\\]"+                              , reCompiled = Just (compileRegex True "\\[\\^[^\\]]+\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[[^\\]\\^]+\\]\\s*\\([^\\(]*\\)"+                              , reCompiled =+                                  Just (compileRegex True "\\[[^\\]\\^]+\\]\\s*\\([^\\(]*\\)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\[[^\\]\\^]+\\]\\:\\s+[^\\s]+(\\s+\\\"[^\\\"]*\\\"){0,1}"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\[[^\\]\\^]+\\]\\:\\s+[^\\s]+(\\s+\\\"[^\\\"]*\\\"){0,1}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\!\\[[^\\]\\^]+\\]\\([^\\(]*\\)"+                              , reCompiled =+                                  Just (compileRegex True "\\!\\[[^\\]\\^]+\\]\\([^\\(]*\\)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\!\\[[^\\]\\^]+\\]\\[[^\\[]*\\]"+                              , reCompiled =+                                  Just (compileRegex True "\\!\\[[^\\]\\^]+\\]\\[[^\\[]*\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<(https?|ftp):[^\\\">\\s]+>"+                              , reCompiled =+                                  Just (compileRegex True "<(https?|ftp):[^\\\">\\s]+>")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "<(?:mailto:)?([-.\\w]+\\@[-a-z0-9]+(\\.[-a-z0-9]+)*\\.[a-z]+)>"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "<(?:mailto:)?([-.\\w]+\\@[-a-z0-9]+(\\.[-a-z0-9]+)*\\.[a-z]+)>")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[~]{2}[^~].*[^~][~]{2}"+                              , reCompiled = Just (compileRegex True "[~]{2}[^~].*[^~][~]{2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "  $"+                              , reCompiled = Just (compileRegex True "  $")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "numlist"+          , Context+              { cName = "numlist"+              , cSyntax = "Markdown"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\s|^)[\\*_]{2}[^\\s]{1}[^\\*_]+[\\*_]{2}(\\s|\\.|,|;|:|\\-|\\?|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(\\s|^)[\\*_]{2}[^\\s]{1}[^\\*_]+[\\*_]{2}(\\s|\\.|,|;|:|\\-|\\?|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\s|^)[\\*_]{1}[^\\s]{1}[^\\*_]+[\\*_]{1}(\\s|\\.|,|;|:|\\-|\\?|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(\\s|^)[\\*_]{1}[^\\s]{1}[^\\*_]+[\\*_]{1}(\\s|\\.|,|;|:|\\-|\\?|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Markdown" , "inc" )+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = FloatTok+              , cLineEmptyContext = [ Pop ]+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Darrin Yeager, Claes Holmerson"+  , sVersion = "2"+  , sLicense = "GPL,BSD"+  , sExtensions = [ "*.md" , "*.mmd" , "*.markdown" ]+  , sStartingContext = "Normal Text"+  }
+ src/Skylighting/Syntax/Mathematica.hs view
@@ -0,0 +1,3334 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Mathematica (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Mathematica"+  , sFilename = "mathematica.xml"+  , sShortname = "Mathematica"+  , sContexts =+      fromList+        [ ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Mathematica"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "$"+                               , "$Aborted"+                               , "$AssertFunction"+                               , "$Assumptions"+                               , "$BaseDirectory"+                               , "$BatchInput"+                               , "$BatchOutput"+                               , "$ByteOrdering"+                               , "$Canceled"+                               , "$CharacterEncoding"+                               , "$CharacterEncodings"+                               , "$CommandLine"+                               , "$CompilationTarget"+                               , "$ConfiguredKernels"+                               , "$Context"+                               , "$ContextPath"+                               , "$ControlActiveSetting"+                               , "$CreationDate"+                               , "$CurrentLink"+                               , "$DateStringFormat"+                               , "$DefaultImagingDevice"+                               , "$Display"+                               , "$DisplayFunction"+                               , "$DistributedContexts"+                               , "$DynamicEvaluation"+                               , "$Echo"+                               , "$Epilog"+                               , "$ExportFormats"+                               , "$Failed"+                               , "$FrontEnd"+                               , "$FrontEndSession"+                               , "$GeoLocation"+                               , "$HistoryLength"+                               , "$HomeDirectory"+                               , "$IgnoreEOF"+                               , "$ImagingDevices"+                               , "$ImportFormats"+                               , "$InitialDirectory"+                               , "$Input"+                               , "$InputFileName"+                               , "$Inspector"+                               , "$InstallationDirectory"+                               , "$IterationLimit"+                               , "$KernelCount"+                               , "$KernelID"+                               , "$Language"+                               , "$LibraryPath"+                               , "$LicenseExpirationDate"+                               , "$LicenseID"+                               , "$LicenseServer"+                               , "$Line"+                               , "$Linked"+                               , "$MachineAddresses"+                               , "$MachineDomains"+                               , "$MachineEpsilon"+                               , "$MachineID"+                               , "$MachineName"+                               , "$MachinePrecision"+                               , "$MachineType"+                               , "$MaxExtraPrecision"+                               , "$MaxMachineNumber"+                               , "$MaxNumber"+                               , "$MaxPiecewiseCases"+                               , "$MaxPrecision"+                               , "$MaxRootDegree"+                               , "$MessageGroups"+                               , "$MessageList"+                               , "$MessagePrePrint"+                               , "$Messages"+                               , "$MinMachineNumber"+                               , "$MinNumber"+                               , "$MinPrecision"+                               , "$ModuleNumber"+                               , "$NewMessage"+                               , "$NewSymbol"+                               , "$Notebooks"+                               , "$NumberMarks"+                               , "$OperatingSystem"+                               , "$Output"+                               , "$OutputSizeLimit"+                               , "$Packages"+                               , "$ParentLink"+                               , "$ParentProcessID"+                               , "$Path"+                               , "$PathnameSeparator"+                               , "$PerformanceGoal"+                               , "$Post"+                               , "$Pre"+                               , "$PrePrint"+                               , "$PreRead"+                               , "$ProcessID"+                               , "$ProcessorCount"+                               , "$ProcessorType"+                               , "$RecursionLimit"+                               , "$ReleaseNumber"+                               , "$RootDirectory"+                               , "$ScheduledTask"+                               , "$ScriptCommandLine"+                               , "$SessionID"+                               , "$SharedFunctions"+                               , "$SharedVariables"+                               , "$SoundDisplayFunction"+                               , "$SyntaxHandler"+                               , "$System"+                               , "$SystemCharacterEncoding"+                               , "$SystemID"+                               , "$SystemWordLength"+                               , "$TemporaryDirectory"+                               , "$TimedOut"+                               , "$TimeUnit"+                               , "$TimeZone"+                               , "$Urgent"+                               , "$UserBaseDirectory"+                               , "$UserDocumentsDirectory"+                               , "$UserName"+                               , "$Version"+                               , "$VersionNumber"+                               , "A"+                               , "AbelianGroup"+                               , "Abort"+                               , "AbortKernels"+                               , "AbortProtect"+                               , "Abs"+                               , "AbsoluteCurrentValue"+                               , "AbsoluteDashing"+                               , "AbsoluteFileName"+                               , "AbsoluteOptions"+                               , "AbsolutePointSize"+                               , "AbsoluteThickness"+                               , "AbsoluteTime"+                               , "AbsoluteTiming"+                               , "AccountingForm"+                               , "Accumulate"+                               , "Accuracy"+                               , "AccuracyGoal"+                               , "ActionMenu"+                               , "ActiveStyle"+                               , "AcyclicGraphQ"+                               , "AddTo"+                               , "AdjacencyGraph"+                               , "AdjacencyMatrix"+                               , "AdjustmentBox"+                               , "AffineTransform"+                               , "AiryAi"+                               , "AiryAiPrime"+                               , "AiryAiZero"+                               , "AiryBi"+                               , "AiryBiPrime"+                               , "AiryBiZero"+                               , "AlgebraicIntegerQ"+                               , "AlgebraicNumber"+                               , "AlgebraicNumberDenominator"+                               , "AlgebraicNumberNorm"+                               , "AlgebraicNumberPolynomial"+                               , "AlgebraicNumberTrace"+                               , "Algebraics"+                               , "AlgebraicUnitQ"+                               , "Alignment"+                               , "AlignmentPoint"+                               , "All"+                               , "AllowGroupClose"+                               , "AllowReverseGroupClose"+                               , "AlphaChannel"+                               , "AlternatingGroup"+                               , "AlternativeHypothesis"+                               , "Alternatives"+                               , "AnchoredSearch"+                               , "And"+                               , "AndersonDarlingTest"+                               , "AngerJ"+                               , "AngleBracket"+                               , "Animate"+                               , "AnimationDirection"+                               , "AnimationDisplayTime"+                               , "AnimationRate"+                               , "AnimationRepetitions"+                               , "AnimationRunning"+                               , "Animator"+                               , "Annotation"+                               , "Annuity"+                               , "AnnuityDue"+                               , "Antialiasing"+                               , "Apart"+                               , "ApartSquareFree"+                               , "Appearance"+                               , "AppearanceElements"+                               , "AppellF1"+                               , "Append"+                               , "AppendTo"+                               , "Apply"+                               , "ArcCos"+                               , "ArcCosh"+                               , "ArcCot"+                               , "ArcCoth"+                               , "ArcCsc"+                               , "ArcCsch"+                               , "ArcSec"+                               , "ArcSech"+                               , "ArcSin"+                               , "ArcSinDistribution"+                               , "ArcSinh"+                               , "ArcTan"+                               , "ArcTanh"+                               , "Arg"+                               , "ArgMax"+                               , "ArgMin"+                               , "ArithmeticGeometricMean"+                               , "Array"+                               , "ArrayComponents"+                               , "ArrayDepth"+                               , "ArrayFlatten"+                               , "ArrayPad"+                               , "ArrayPlot"+                               , "ArrayQ"+                               , "ArrayRules"+                               , "Arrow"+                               , "Arrowheads"+                               , "AspectRatio"+                               , "Assert"+                               , "Assuming"+                               , "Assumptions"+                               , "AstronomicalData"+                               , "Asynchronous"+                               , "AtomQ"+                               , "Attributes"+                               , "AugmentedSymmetricPolynomial"+                               , "AutoAction"+                               , "AutoIndent"+                               , "AutoItalicWords"+                               , "Automatic"+                               , "AutoMultiplicationSymbol"+                               , "AutorunSequencing"+                               , "AutoScroll"+                               , "AutoSpacing"+                               , "Axes"+                               , "AxesEdge"+                               , "AxesLabel"+                               , "AxesOrigin"+                               , "AxesStyle"+                               , "Axis"+                               , "B"+                               , "BabyMonsterGroupB"+                               , "Back"+                               , "Background"+                               , "Backslash"+                               , "Backward"+                               , "Band"+                               , "BarabasiAlbertGraphDistribution"+                               , "BarChart"+                               , "BarChart3D"+                               , "BarnesG"+                               , "BarOrigin"+                               , "BarSpacing"+                               , "BaseForm"+                               , "Baseline"+                               , "BaselinePosition"+                               , "BaseStyle"+                               , "BatesDistribution"+                               , "BattleLemarieWavelet"+                               , "Because"+                               , "BeckmannDistribution"+                               , "Beep"+                               , "Begin"+                               , "BeginDialogPacket"+                               , "BeginPackage"+                               , "BellB"+                               , "BellY"+                               , "BenfordDistribution"+                               , "BeniniDistribution"+                               , "BenktanderGibratDistribution"+                               , "BenktanderWeibullDistribution"+                               , "BernoulliB"+                               , "BernoulliDistribution"+                               , "BernoulliGraphDistribution"+                               , "BernsteinBasis"+                               , "BesselI"+                               , "BesselJ"+                               , "BesselJZero"+                               , "BesselK"+                               , "BesselY"+                               , "BesselYZero"+                               , "Beta"+                               , "BetaBinomialDistribution"+                               , "BetaDistribution"+                               , "BetaNegativeBinomialDistribution"+                               , "BetaPrimeDistribution"+                               , "BetaRegularized"+                               , "BetweennessCentrality"+                               , "BezierCurve"+                               , "BezierFunction"+                               , "BilateralFilter"+                               , "Binarize"+                               , "BinaryFormat"+                               , "BinaryImageQ"+                               , "BinaryRead"+                               , "BinaryReadList"+                               , "BinaryWrite"+                               , "BinCounts"+                               , "BinLists"+                               , "Binomial"+                               , "BinomialDistribution"+                               , "BinormalDistribution"+                               , "BiorthogonalSplineWavelet"+                               , "BipartiteGraphQ"+                               , "BirnbaumSaundersDistribution"+                               , "BitAnd"+                               , "BitClear"+                               , "BitGet"+                               , "BitLength"+                               , "BitNot"+                               , "BitOr"+                               , "BitSet"+                               , "BitShiftLeft"+                               , "BitShiftRight"+                               , "BitXor"+                               , "Black"+                               , "Blank"+                               , "BlankNullSequence"+                               , "BlankSequence"+                               , "Blend"+                               , "Block"+                               , "BlockRandom"+                               , "Blue"+                               , "Blur"+                               , "BodePlot"+                               , "Bold"+                               , "Bookmarks"+                               , "Boole"+                               , "BooleanConvert"+                               , "BooleanCountingFunction"+                               , "BooleanFunction"+                               , "BooleanGraph"+                               , "BooleanMaxterms"+                               , "BooleanMinimize"+                               , "BooleanMinterms"+                               , "Booleans"+                               , "BooleanTable"+                               , "BooleanVariables"+                               , "BorderDimensions"+                               , "BorelTannerDistribution"+                               , "Bottom"+                               , "BottomHatTransform"+                               , "BoundaryStyle"+                               , "BoxData"+                               , "Boxed"+                               , "BoxMatrix"+                               , "BoxRatios"+                               , "BoxStyle"+                               , "BoxWhiskerChart"+                               , "BracketingBar"+                               , "BrayCurtisDistance"+                               , "BreadthFirstScan"+                               , "Break"+                               , "Brown"+                               , "BrownForsytheTest"+                               , "BSplineBasis"+                               , "BSplineCurve"+                               , "BSplineFunction"+                               , "BSplineSurface"+                               , "BubbleChart"+                               , "BubbleChart3D"+                               , "BubbleScale"+                               , "BubbleSizes"+                               , "ButterflyGraph"+                               , "Button"+                               , "ButtonBar"+                               , "ButtonBox"+                               , "ButtonData"+                               , "ButtonFrame"+                               , "ButtonFunction"+                               , "ButtonMinHeight"+                               , "ButtonNotebook"+                               , "ButtonSource"+                               , "Byte"+                               , "ByteCount"+                               , "ByteOrdering"+                               , "C"+                               , "CallPacket"+                               , "CanberraDistance"+                               , "Cancel"+                               , "CancelButton"+                               , "CandlestickChart"+                               , "Cap"+                               , "CapForm"+                               , "CapitalDifferentialD"+                               , "CarmichaelLambda"+                               , "Cases"+                               , "Cashflow"+                               , "Casoratian"+                               , "Catalan"+                               , "CatalanNumber"+                               , "Catch"+                               , "CauchyDistribution"+                               , "CayleyGraph"+                               , "CDF"+                               , "CDFWavelet"+                               , "Ceiling"+                               , "Cell"+                               , "CellAutoOverwrite"+                               , "CellBaseline"+                               , "CellChangeTimes"+                               , "CellContext"+                               , "CellDingbat"+                               , "CellDynamicExpression"+                               , "CellEditDuplicate"+                               , "CellEpilog"+                               , "CellEvaluationDuplicate"+                               , "CellEvaluationFunction"+                               , "CellEventActions"+                               , "CellFrame"+                               , "CellFrameMargins"+                               , "CellGroup"+                               , "CellGroupData"+                               , "CellGrouping"+                               , "CellLabel"+                               , "CellLabelAutoDelete"+                               , "CellMargins"+                               , "CellOpen"+                               , "CellPrint"+                               , "CellProlog"+                               , "CellTags"+                               , "CellularAutomaton"+                               , "CensoredDistribution"+                               , "Censoring"+                               , "Center"+                               , "CenterDot"+                               , "CentralMoment"+                               , "CentralMomentGeneratingFunction"+                               , "CForm"+                               , "ChampernowneNumber"+                               , "ChanVeseBinarize"+                               , "Character"+                               , "CharacterEncoding"+                               , "CharacteristicFunction"+                               , "CharacteristicPolynomial"+                               , "CharacterRange"+                               , "Characters"+                               , "ChartBaseStyle"+                               , "ChartElementFunction"+                               , "ChartElements"+                               , "ChartLabels"+                               , "ChartLayout"+                               , "ChartLegends"+                               , "ChartStyle"+                               , "ChebyshevT"+                               , "ChebyshevU"+                               , "Check"+                               , "CheckAbort"+                               , "Checkbox"+                               , "CheckboxBar"+                               , "ChemicalData"+                               , "ChessboardDistance"+                               , "ChiDistribution"+                               , "ChineseRemainder"+                               , "ChiSquareDistribution"+                               , "ChoiceButtons"+                               , "ChoiceDialog"+                               , "CholeskyDecomposition"+                               , "Chop"+                               , "Circle"+                               , "CircleDot"+                               , "CircleMinus"+                               , "CirclePlus"+                               , "CircleTimes"+                               , "CirculantGraph"+                               , "CityData"+                               , "Clear"+                               , "ClearAll"+                               , "ClearAttributes"+                               , "ClearSystemCache"+                               , "ClebschGordan"+                               , "ClickPane"+                               , "Clip"+                               , "ClippingStyle"+                               , "Clock"+                               , "Close"+                               , "CloseKernels"+                               , "ClosenessCentrality"+                               , "Closing"+                               , "ClusteringComponents"+                               , "CMYKColor"+                               , "Coefficient"+                               , "CoefficientArrays"+                               , "CoefficientList"+                               , "CoefficientRules"+                               , "CoifletWavelet"+                               , "Collect"+                               , "Colon"+                               , "ColorCombine"+                               , "ColorConvert"+                               , "ColorData"+                               , "ColorDataFunction"+                               , "ColorFunction"+                               , "ColorFunctionScaling"+                               , "Colorize"+                               , "ColorNegate"+                               , "ColorQuantize"+                               , "ColorRules"+                               , "ColorSeparate"+                               , "ColorSetter"+                               , "ColorSlider"+                               , "ColorSpace"+                               , "Column"+                               , "ColumnAlignments"+                               , "ColumnLines"+                               , "ColumnsEqual"+                               , "ColumnSpacings"+                               , "ColumnWidths"+                               , "Commonest"+                               , "CommonestFilter"+                               , "CompilationOptions"+                               , "CompilationTarget"+                               , "Compile"+                               , "Compiled"+                               , "CompiledFunction"+                               , "Complement"+                               , "CompleteGraph"+                               , "CompleteGraphQ"+                               , "CompleteKaryTree"+                               , "Complex"+                               , "Complexes"+                               , "ComplexExpand"+                               , "ComplexInfinity"+                               , "ComplexityFunction"+                               , "ComponentMeasurements"+                               , "ComposeList"+                               , "ComposeSeries"+                               , "Composition"+                               , "CompoundExpression"+                               , "Compress"+                               , "Condition"+                               , "ConditionalExpression"+                               , "Conditioned"+                               , "Cone"+                               , "ConfidenceLevel"+                               , "Congruent"+                               , "Conjugate"+                               , "ConjugateTranspose"+                               , "Conjunction"+                               , "ConnectedComponents"+                               , "ConnectedGraphQ"+                               , "ConoverTest"+                               , "Constant"+                               , "ConstantArray"+                               , "Constants"+                               , "ContentPadding"+                               , "ContentSelectable"+                               , "ContentSize"+                               , "Context"+                               , "Contexts"+                               , "ContextToFileName"+                               , "Continue"+                               , "ContinuedFraction"+                               , "ContinuedFractionK"+                               , "ContinuousAction"+                               , "ContinuousTimeModelQ"+                               , "ContinuousWaveletData"+                               , "ContinuousWaveletTransform"+                               , "ContourDetect"+                               , "ContourLabels"+                               , "ContourPlot"+                               , "ContourPlot3D"+                               , "Contours"+                               , "ContourShading"+                               , "ContourStyle"+                               , "ContraharmonicMean"+                               , "Control"+                               , "ControlActive"+                               , "ControllabilityGramian"+                               , "ControllabilityMatrix"+                               , "ControllableDecomposition"+                               , "ControllableModelQ"+                               , "ControllerInformation"+                               , "ControllerLinking"+                               , "ControllerManipulate"+                               , "ControllerMethod"+                               , "ControllerPath"+                               , "ControllerState"+                               , "ControlPlacement"+                               , "ControlsRendering"+                               , "ControlType"+                               , "Convergents"+                               , "ConversionRules"+                               , "Convolve"+                               , "ConwayGroupCo1"+                               , "ConwayGroupCo2"+                               , "ConwayGroupCo3"+                               , "CoordinatesToolOptions"+                               , "CoprimeQ"+                               , "Coproduct"+                               , "CopulaDistribution"+                               , "Copyable"+                               , "CopyDirectory"+                               , "CopyFile"+                               , "CopyToClipboard"+                               , "CornerFilter"+                               , "CornerNeighbors"+                               , "Correlation"+                               , "CorrelationDistance"+                               , "Cos"+                               , "Cosh"+                               , "CoshIntegral"+                               , "CosineDistance"+                               , "CosIntegral"+                               , "Cot"+                               , "Coth"+                               , "Count"+                               , "CountRoots"+                               , "CountryData"+                               , "Covariance"+                               , "CovarianceEstimatorFunction"+                               , "CramerVonMisesTest"+                               , "CreateArchive"+                               , "CreateDialog"+                               , "CreateDirectory"+                               , "CreateDocument"+                               , "CreateIntermediateDirectories"+                               , "CreatePalette"+                               , "CreateScheduledTask"+                               , "CreateWindow"+                               , "CriticalSection"+                               , "Cross"+                               , "CrossingDetect"+                               , "CrossMatrix"+                               , "Csc"+                               , "Csch"+                               , "Cubics"+                               , "Cuboid"+                               , "Cumulant"+                               , "CumulantGeneratingFunction"+                               , "Cup"+                               , "CupCap"+                               , "CurrentImage"+                               , "CurrentValue"+                               , "CurvatureFlowFilter"+                               , "CurveClosed"+                               , "Cyan"+                               , "CycleGraph"+                               , "Cycles"+                               , "CyclicGroup"+                               , "Cyclotomic"+                               , "Cylinder"+                               , "CylindricalDecomposition"+                               , "D"+                               , "DagumDistribution"+                               , "DamerauLevenshteinDistance"+                               , "Darker"+                               , "Dashed"+                               , "Dashing"+                               , "DataDistribution"+                               , "DataRange"+                               , "DataReversed"+                               , "DateDifference"+                               , "DateFunction"+                               , "DateList"+                               , "DateListLogPlot"+                               , "DateListPlot"+                               , "DatePattern"+                               , "DatePlus"+                               , "DateString"+                               , "DateTicksFormat"+                               , "DaubechiesWavelet"+                               , "DavisDistribution"+                               , "DawsonF"+                               , "DeBruijnGraph"+                               , "DeclarePackage"+                               , "Decompose"+                               , "Decrement"+                               , "DedekindEta"+                               , "Default"+                               , "DefaultAxesStyle"+                               , "DefaultBaseStyle"+                               , "DefaultBoxStyle"+                               , "DefaultButton"+                               , "DefaultDuplicateCellStyle"+                               , "DefaultDuration"+                               , "DefaultElement"+                               , "DefaultFaceGridsStyle"+                               , "DefaultFieldHintStyle"+                               , "DefaultFrameStyle"+                               , "DefaultFrameTicksStyle"+                               , "DefaultGridLinesStyle"+                               , "DefaultLabelStyle"+                               , "DefaultMenuStyle"+                               , "DefaultNewCellStyle"+                               , "DefaultOptions"+                               , "DefaultTicksStyle"+                               , "Defer"+                               , "Definition"+                               , "Degree"+                               , "DegreeCentrality"+                               , "DegreeGraphDistribution"+                               , "Deinitialization"+                               , "Del"+                               , "Deletable"+                               , "Delete"+                               , "DeleteBorderComponents"+                               , "DeleteCases"+                               , "DeleteContents"+                               , "DeleteDirectory"+                               , "DeleteDuplicates"+                               , "DeleteFile"+                               , "DeleteSmallComponents"+                               , "Delimiter"+                               , "DelimiterFlashTime"+                               , "Denominator"+                               , "DensityHistogram"+                               , "DensityPlot"+                               , "DependentVariables"+                               , "Deploy"+                               , "Deployed"+                               , "Depth"+                               , "DepthFirstScan"+                               , "Derivative"+                               , "DerivativeFilter"+                               , "DesignMatrix"+                               , "Det"+                               , "DGaussianWavelet"+                               , "Diagonal"+                               , "DiagonalMatrix"+                               , "Dialog"+                               , "DialogInput"+                               , "DialogNotebook"+                               , "DialogProlog"+                               , "DialogReturn"+                               , "DialogSymbols"+                               , "Diamond"+                               , "DiamondMatrix"+                               , "DiceDissimilarity"+                               , "DictionaryLookup"+                               , "DifferenceDelta"+                               , "DifferenceRoot"+                               , "DifferenceRootReduce"+                               , "Differences"+                               , "DifferentialD"+                               , "DifferentialRoot"+                               , "DifferentialRootReduce"+                               , "DigitBlock"+                               , "DigitCharacter"+                               , "DigitCount"+                               , "DigitQ"+                               , "DihedralGroup"+                               , "Dilation"+                               , "Dimensions"+                               , "DiracComb"+                               , "DiracDelta"+                               , "DirectedEdge"+                               , "DirectedEdges"+                               , "DirectedGraph"+                               , "DirectedGraphQ"+                               , "DirectedInfinity"+                               , "Direction"+                               , "Directive"+                               , "Directory"+                               , "DirectoryName"+                               , "DirectoryQ"+                               , "DirectoryStack"+                               , "DirichletCharacter"+                               , "DirichletConvolve"+                               , "DirichletDistribution"+                               , "DirichletL"+                               , "DirichletTransform"+                               , "DiscreteConvolve"+                               , "DiscreteDelta"+                               , "DiscreteIndicator"+                               , "DiscreteLQEstimatorGains"+                               , "DiscreteLQRegulatorGains"+                               , "DiscreteLyapunovSolve"+                               , "DiscretePlot"+                               , "DiscretePlot3D"+                               , "DiscreteRatio"+                               , "DiscreteRiccatiSolve"+                               , "DiscreteShift"+                               , "DiscreteTimeModelQ"+                               , "DiscreteUniformDistribution"+                               , "DiscreteWaveletData"+                               , "DiscreteWaveletPacketTransform"+                               , "DiscreteWaveletTransform"+                               , "Discriminant"+                               , "Disjunction"+                               , "Disk"+                               , "DiskMatrix"+                               , "Dispatch"+                               , "DispersionEstimatorFunction"+                               , "DisplayAllSteps"+                               , "DisplayEndPacket"+                               , "DisplayForm"+                               , "DisplayFunction"+                               , "DisplayPacket"+                               , "DistanceFunction"+                               , "DistanceTransform"+                               , "Distribute"+                               , "Distributed"+                               , "DistributedContexts"+                               , "DistributeDefinitions"+                               , "DistributionChart"+                               , "DistributionFitTest"+                               , "DistributionParameterAssumptions"+                               , "DistributionParameterQ"+                               , "Divide"+                               , "DivideBy"+                               , "Dividers"+                               , "Divisible"+                               , "Divisors"+                               , "DivisorSigma"+                               , "DivisorSum"+                               , "DMSList"+                               , "DMSString"+                               , "Do"+                               , "DockedCells"+                               , "DocumentNotebook"+                               , "Dot"+                               , "DotDashed"+                               , "DotEqual"+                               , "Dotted"+                               , "DoubleBracketingBar"+                               , "DoubleDownArrow"+                               , "DoubleLeftArrow"+                               , "DoubleLeftRightArrow"+                               , "DoubleLongLeftArrow"+                               , "DoubleLongLeftRightArrow"+                               , "DoubleLongRightArrow"+                               , "DoubleRightArrow"+                               , "DoubleUpArrow"+                               , "DoubleUpDownArrow"+                               , "DoubleVerticalBar"+                               , "DownArrow"+                               , "DownArrowBar"+                               , "DownArrowUpArrow"+                               , "DownLeftRightVector"+                               , "DownLeftTeeVector"+                               , "DownLeftVector"+                               , "DownLeftVectorBar"+                               , "DownRightTeeVector"+                               , "DownRightVector"+                               , "DownRightVectorBar"+                               , "DownTeeArrow"+                               , "DownValues"+                               , "DragAndDrop"+                               , "Drop"+                               , "DSolve"+                               , "Dt"+                               , "DualSystemsModel"+                               , "DumpSave"+                               , "Dynamic"+                               , "DynamicEvaluationTimeout"+                               , "DynamicModule"+                               , "DynamicModuleValues"+                               , "DynamicSetting"+                               , "DynamicWrapper"+                               , "E"+                               , "EdgeAdd"+                               , "EdgeCount"+                               , "EdgeCoverQ"+                               , "EdgeDelete"+                               , "EdgeDetect"+                               , "EdgeForm"+                               , "EdgeIndex"+                               , "EdgeLabeling"+                               , "EdgeLabels"+                               , "EdgeList"+                               , "EdgeQ"+                               , "EdgeRenderingFunction"+                               , "EdgeRules"+                               , "EdgeShapeFunction"+                               , "EdgeStyle"+                               , "EdgeWeight"+                               , "Editable"+                               , "EditDistance"+                               , "EffectiveInterest"+                               , "Eigensystem"+                               , "Eigenvalues"+                               , "EigenvectorCentrality"+                               , "Eigenvectors"+                               , "Element"+                               , "ElementData"+                               , "Eliminate"+                               , "EllipticE"+                               , "EllipticExp"+                               , "EllipticExpPrime"+                               , "EllipticF"+                               , "EllipticK"+                               , "EllipticLog"+                               , "EllipticNomeQ"+                               , "EllipticPi"+                               , "EllipticTheta"+                               , "EllipticThetaPrime"+                               , "EmitSound"+                               , "EmpiricalDistribution"+                               , "EmptyGraphQ"+                               , "Enabled"+                               , "Encode"+                               , "End"+                               , "EndDialogPacket"+                               , "EndOfFile"+                               , "EndOfLine"+                               , "EndOfString"+                               , "EndPackage"+                               , "EngineeringForm"+                               , "EnterExpressionPacket"+                               , "EnterTextPacket"+                               , "Entropy"+                               , "EntropyFilter"+                               , "Environment"+                               , "Epilog"+                               , "Equal"+                               , "EqualTilde"+                               , "Equilibrium"+                               , "Equivalent"+                               , "Erf"+                               , "Erfc"+                               , "Erfi"+                               , "ErlangDistribution"+                               , "Erosion"+                               , "ErrorBox"+                               , "EstimatedDistribution"+                               , "EstimatorGains"+                               , "EstimatorRegulator"+                               , "EuclideanDistance"+                               , "EulerE"+                               , "EulerGamma"+                               , "EulerianGraphQ"+                               , "EulerPhi"+                               , "Evaluatable"+                               , "Evaluate"+                               , "EvaluatePacket"+                               , "EvaluationElements"+                               , "EvaluationMonitor"+                               , "EvaluationNotebook"+                               , "EvaluationObject"+                               , "Evaluator"+                               , "EvenQ"+                               , "EventHandler"+                               , "EventLabels"+                               , "ExactNumberQ"+                               , "ExampleData"+                               , "Except"+                               , "ExcludedForms"+                               , "ExcludePods"+                               , "Exclusions"+                               , "ExclusionsStyle"+                               , "Exists"+                               , "Exit"+                               , "Exp"+                               , "Expand"+                               , "ExpandAll"+                               , "ExpandDenominator"+                               , "ExpandFileName"+                               , "ExpandNumerator"+                               , "Expectation"+                               , "ExpGammaDistribution"+                               , "ExpIntegralE"+                               , "ExpIntegralEi"+                               , "Exponent"+                               , "ExponentFunction"+                               , "ExponentialDistribution"+                               , "ExponentialFamily"+                               , "ExponentialGeneratingFunction"+                               , "ExponentialMovingAverage"+                               , "ExponentialPowerDistribution"+                               , "ExponentStep"+                               , "Export"+                               , "ExportString"+                               , "Expression"+                               , "ExpressionCell"+                               , "ExpToTrig"+                               , "ExtendedGCD"+                               , "Extension"+                               , "ExtentElementFunction"+                               , "ExtentMarkers"+                               , "ExtentSize"+                               , "Extract"+                               , "ExtractArchive"+                               , "ExtremeValueDistribution"+                               , "F"+                               , "FaceForm"+                               , "FaceGrids"+                               , "FaceGridsStyle"+                               , "Factor"+                               , "Factorial"+                               , "Factorial2"+                               , "FactorialMoment"+                               , "FactorialMomentGeneratingFunction"+                               , "FactorialPower"+                               , "FactorInteger"+                               , "FactorList"+                               , "FactorSquareFree"+                               , "FactorSquareFreeList"+                               , "FactorTerms"+                               , "FactorTermsList"+                               , "False"+                               , "FeedbackType"+                               , "Fibonacci"+                               , "FieldHint"+                               , "FieldHintStyle"+                               , "FieldMasked"+                               , "FieldSize"+                               , "FileBaseName"+                               , "FileByteCount"+                               , "FileDate"+                               , "FileExistsQ"+                               , "FileExtension"+                               , "FileFormat"+                               , "FileHash"+                               , "FileNameDepth"+                               , "FileNameDrop"+                               , "FileNameJoin"+                               , "FileNames"+                               , "FileNameSetter"+                               , "FileNameSplit"+                               , "FileNameTake"+                               , "FilePrint"+                               , "FileType"+                               , "FilledCurve"+                               , "Filling"+                               , "FillingStyle"+                               , "FillingTransform"+                               , "FilterRules"+                               , "FinancialBond"+                               , "FinancialData"+                               , "FinancialDerivative"+                               , "FinancialIndicator"+                               , "Find"+                               , "FindArgMax"+                               , "FindArgMin"+                               , "FindClique"+                               , "FindClusters"+                               , "FindCurvePath"+                               , "FindDistributionParameters"+                               , "FindDivisions"+                               , "FindEdgeCover"+                               , "FindEulerianCycle"+                               , "FindFile"+                               , "FindFit"+                               , "FindGeneratingFunction"+                               , "FindGeoLocation"+                               , "FindGeometricTransform"+                               , "FindGraphIsomorphism"+                               , "FindHamiltonianCycle"+                               , "FindIndependentEdgeSet"+                               , "FindIndependentVertexSet"+                               , "FindInstance"+                               , "FindIntegerNullVector"+                               , "FindLibrary"+                               , "FindLinearRecurrence"+                               , "FindList"+                               , "FindMaximum"+                               , "FindMaxValue"+                               , "FindMinimum"+                               , "FindMinValue"+                               , "FindPermutation"+                               , "FindRoot"+                               , "FindSequenceFunction"+                               , "FindShortestPath"+                               , "FindShortestTour"+                               , "FindThreshold"+                               , "FindVertexCover"+                               , "FinishDynamic"+                               , "FiniteAbelianGroupCount"+                               , "FiniteGroupCount"+                               , "FiniteGroupData"+                               , "First"+                               , "FischerGroupFi22"+                               , "FischerGroupFi23"+                               , "FischerGroupFi24Prime"+                               , "FisherHypergeometricDistribution"+                               , "FisherRatioTest"+                               , "FisherZDistribution"+                               , "Fit"+                               , "FittedModel"+                               , "FixedPoint"+                               , "FixedPointList"+                               , "Flat"+                               , "Flatten"+                               , "FlattenAt"+                               , "FlipView"+                               , "Floor"+                               , "Fold"+                               , "FoldList"+                               , "FontColor"+                               , "FontFamily"+                               , "FontSize"+                               , "FontSlant"+                               , "FontSubstitutions"+                               , "FontTracking"+                               , "FontVariations"+                               , "FontWeight"+                               , "For"+                               , "ForAll"+                               , "Format"+                               , "FormatType"+                               , "FormBox"+                               , "FortranForm"+                               , "Forward"+                               , "ForwardBackward"+                               , "Fourier"+                               , "FourierCoefficient"+                               , "FourierCosCoefficient"+                               , "FourierCosSeries"+                               , "FourierCosTransform"+                               , "FourierDCT"+                               , "FourierDST"+                               , "FourierParameters"+                               , "FourierSequenceTransform"+                               , "FourierSeries"+                               , "FourierSinCoefficient"+                               , "FourierSinSeries"+                               , "FourierSinTransform"+                               , "FourierTransform"+                               , "FourierTrigSeries"+                               , "FractionalPart"+                               , "FractionBox"+                               , "Frame"+                               , "FrameBox"+                               , "Framed"+                               , "FrameLabel"+                               , "FrameMargins"+                               , "FrameStyle"+                               , "FrameTicks"+                               , "FrameTicksStyle"+                               , "FRatioDistribution"+                               , "FrechetDistribution"+                               , "FreeQ"+                               , "FresnelC"+                               , "FresnelS"+                               , "FrobeniusNumber"+                               , "FrobeniusSolve"+                               , "FromCharacterCode"+                               , "FromCoefficientRules"+                               , "FromContinuedFraction"+                               , "FromDigits"+                               , "FromDMS"+                               , "Front"+                               , "FrontEndDynamicExpression"+                               , "FrontEndEventActions"+                               , "FrontEndExecute"+                               , "FrontEndToken"+                               , "FrontEndTokenExecute"+                               , "Full"+                               , "FullDefinition"+                               , "FullForm"+                               , "FullGraphics"+                               , "FullSimplify"+                               , "Function"+                               , "FunctionExpand"+                               , "FunctionInterpolation"+                               , "FunctionSpace"+                               , "G"+                               , "GaborWavelet"+                               , "GainMargins"+                               , "GainPhaseMargins"+                               , "Gamma"+                               , "GammaDistribution"+                               , "GammaRegularized"+                               , "GapPenalty"+                               , "Gather"+                               , "GatherBy"+                               , "GaussianFilter"+                               , "GaussianIntegers"+                               , "GaussianMatrix"+                               , "GCD"+                               , "GegenbauerC"+                               , "General"+                               , "GeneralizedLinearModelFit"+                               , "GenerateConditions"+                               , "GeneratedCell"+                               , "GeneratedParameters"+                               , "GeneratingFunction"+                               , "GenericCylindricalDecomposition"+                               , "GenomeData"+                               , "GenomeLookup"+                               , "GeodesicDilation"+                               , "GeodesicErosion"+                               , "GeoDestination"+                               , "GeodesyData"+                               , "GeoDirection"+                               , "GeoDistance"+                               , "GeoGridPosition"+                               , "GeometricDistribution"+                               , "GeometricMean"+                               , "GeometricMeanFilter"+                               , "GeometricTransformation"+                               , "GeoPosition"+                               , "GeoPositionENU"+                               , "GeoPositionXYZ"+                               , "GeoProjectionData"+                               , "Get"+                               , "Glaisher"+                               , "Glow"+                               , "GoldenRatio"+                               , "GompertzMakehamDistribution"+                               , "Goto"+                               , "Gradient"+                               , "GradientFilter"+                               , "Graph"+                               , "GraphCenter"+                               , "GraphComplement"+                               , "GraphData"+                               , "GraphDiameter"+                               , "GraphDifference"+                               , "GraphDisjointUnion"+                               , "GraphDistance"+                               , "GraphDistanceMatrix"+                               , "GraphHighlight"+                               , "GraphHighlightStyle"+                               , "Graphics"+                               , "Graphics3D"+                               , "GraphicsColumn"+                               , "GraphicsComplex"+                               , "GraphicsGrid"+                               , "GraphicsGroup"+                               , "GraphicsRow"+                               , "GraphIntersection"+                               , "GraphLayout"+                               , "GraphPeriphery"+                               , "GraphPlot"+                               , "GraphPlot3D"+                               , "GraphPower"+                               , "GraphQ"+                               , "GraphRadius"+                               , "GraphStyle"+                               , "GraphUnion"+                               , "Gray"+                               , "GrayLevel"+                               , "Greater"+                               , "GreaterEqual"+                               , "GreaterEqualLess"+                               , "GreaterFullEqual"+                               , "GreaterGreater"+                               , "GreaterLess"+                               , "GreaterSlantEqual"+                               , "GreaterTilde"+                               , "Green"+                               , "Grid"+                               , "GridBox"+                               , "GridDefaultElement"+                               , "GridGraph"+                               , "GridLines"+                               , "GridLinesStyle"+                               , "GroebnerBasis"+                               , "GroupActionBase"+                               , "GroupCentralizer"+                               , "GroupElementPosition"+                               , "GroupElementQ"+                               , "GroupElements"+                               , "GroupGenerators"+                               , "GroupMultiplicationTable"+                               , "GroupOrbits"+                               , "GroupOrder"+                               , "GroupPageBreakWithin"+                               , "GroupSetwiseStabilizer"+                               , "GroupStabilizer"+                               , "GroupStabilizerChain"+                               , "Gudermannian"+                               , "GumbelDistribution"+                               , "H"+                               , "HaarWavelet"+                               , "HalfNormalDistribution"+                               , "HamiltonianGraphQ"+                               , "HammingDistance"+                               , "HankelH1"+                               , "HankelH2"+                               , "HankelMatrix"+                               , "HaradaNortonGroupHN"+                               , "HararyGraph"+                               , "HarmonicMean"+                               , "HarmonicMeanFilter"+                               , "HarmonicNumber"+                               , "Hash"+                               , "Haversine"+                               , "HazardFunction"+                               , "Head"+                               , "Heads"+                               , "HeavisideLambda"+                               , "HeavisidePi"+                               , "HeavisideTheta"+                               , "HeldGroupHe"+                               , "HermiteDecomposition"+                               , "HermiteH"+                               , "HermitianMatrixQ"+                               , "HessenbergDecomposition"+                               , "HexadecimalCharacter"+                               , "HighlightGraph"+                               , "HigmanSimsGroupHS"+                               , "HilbertMatrix"+                               , "Histogram"+                               , "Histogram3D"+                               , "HistogramDistribution"+                               , "HistogramList"+                               , "HitMissTransform"+                               , "HITSCentrality"+                               , "Hold"+                               , "HoldAll"+                               , "HoldAllComplete"+                               , "HoldComplete"+                               , "HoldFirst"+                               , "HoldForm"+                               , "HoldPattern"+                               , "HoldRest"+                               , "HornerForm"+                               , "HotellingTSquareDistribution"+                               , "HoytDistribution"+                               , "Hue"+                               , "HumpDownHump"+                               , "HumpEqual"+                               , "HurwitzLerchPhi"+                               , "HurwitzZeta"+                               , "HyperbolicDistribution"+                               , "HypercubeGraph"+                               , "Hyperfactorial"+                               , "Hypergeometric0F1"+                               , "Hypergeometric0F1Regularized"+                               , "Hypergeometric1F1"+                               , "Hypergeometric1F1Regularized"+                               , "Hypergeometric2F1"+                               , "Hypergeometric2F1Regularized"+                               , "HypergeometricDistribution"+                               , "HypergeometricPFQ"+                               , "HypergeometricPFQRegularized"+                               , "HypergeometricU"+                               , "Hyperlink"+                               , "Hyphenation"+                               , "HypothesisTestData"+                               , "I"+                               , "Identity"+                               , "IdentityMatrix"+                               , "If"+                               , "IgnoreCase"+                               , "Im"+                               , "Image"+                               , "ImageAdd"+                               , "ImageAdjust"+                               , "ImageAlign"+                               , "ImageApply"+                               , "ImageAspectRatio"+                               , "ImageAssemble"+                               , "ImageCapture"+                               , "ImageChannels"+                               , "ImageClip"+                               , "ImageColorSpace"+                               , "ImageCompose"+                               , "ImageConvolve"+                               , "ImageCooccurrence"+                               , "ImageCorrelate"+                               , "ImageCorrespondingPoints"+                               , "ImageCrop"+                               , "ImageData"+                               , "ImageDeconvolve"+                               , "ImageDifference"+                               , "ImageDimensions"+                               , "ImageEffect"+                               , "ImageFilter"+                               , "ImageForestingComponents"+                               , "ImageForwardTransformation"+                               , "ImageHistogram"+                               , "ImageKeypoints"+                               , "ImageLevels"+                               , "ImageLines"+                               , "ImageMargins"+                               , "ImageMultiply"+                               , "ImagePad"+                               , "ImagePadding"+                               , "ImagePartition"+                               , "ImagePerspectiveTransformation"+                               , "ImageQ"+                               , "ImageReflect"+                               , "ImageResize"+                               , "ImageResolution"+                               , "ImageRotate"+                               , "ImageScaled"+                               , "ImageSize"+                               , "ImageSizeAction"+                               , "ImageSizeMultipliers"+                               , "ImageSubtract"+                               , "ImageTake"+                               , "ImageTransformation"+                               , "ImageTrim"+                               , "ImageType"+                               , "ImageValue"+                               , "Implies"+                               , "Import"+                               , "ImportString"+                               , "In"+                               , "IncidenceGraph"+                               , "IncidenceMatrix"+                               , "IncludeConstantBasis"+                               , "IncludePods"+                               , "Increment"+                               , "IndependentEdgeSetQ"+                               , "IndependentVertexSetQ"+                               , "Indeterminate"+                               , "IndexGraph"+                               , "InexactNumberQ"+                               , "Infinity"+                               , "Infix"+                               , "Information"+                               , "Inherited"+                               , "Initialization"+                               , "InitializationCell"+                               , "Inner"+                               , "Inpaint"+                               , "Input"+                               , "InputAliases"+                               , "InputAssumptions"+                               , "InputAutoReplacements"+                               , "InputField"+                               , "InputForm"+                               , "InputNamePacket"+                               , "InputNotebook"+                               , "InputPacket"+                               , "InputStream"+                               , "InputString"+                               , "InputStringPacket"+                               , "Insert"+                               , "InsertResults"+                               , "Inset"+                               , "Install"+                               , "InstallService"+                               , "InString"+                               , "Integer"+                               , "IntegerDigits"+                               , "IntegerExponent"+                               , "IntegerLength"+                               , "IntegerPart"+                               , "IntegerPartitions"+                               , "IntegerQ"+                               , "Integers"+                               , "IntegerString"+                               , "Integrate"+                               , "InteractiveTradingChart"+                               , "Interleaving"+                               , "InternallyBalancedDecomposition"+                               , "InterpolatingFunction"+                               , "InterpolatingPolynomial"+                               , "Interpolation"+                               , "InterpolationOrder"+                               , "Interpretation"+                               , "InterpretationBox"+                               , "InterquartileRange"+                               , "Interrupt"+                               , "Intersection"+                               , "Interval"+                               , "IntervalIntersection"+                               , "IntervalMemberQ"+                               , "IntervalUnion"+                               , "Inverse"+                               , "InverseBetaRegularized"+                               , "InverseCDF"+                               , "InverseChiSquareDistribution"+                               , "InverseContinuousWaveletTransform"+                               , "InverseDistanceTransform"+                               , "InverseEllipticNomeQ"+                               , "InverseErf"+                               , "InverseErfc"+                               , "InverseFourier"+                               , "InverseFourierCosTransform"+                               , "InverseFourierSequenceTransform"+                               , "InverseFourierSinTransform"+                               , "InverseFourierTransform"+                               , "InverseFunction"+                               , "InverseFunctions"+                               , "InverseGammaDistribution"+                               , "InverseGammaRegularized"+                               , "InverseGaussianDistribution"+                               , "InverseGudermannian"+                               , "InverseHaversine"+                               , "InverseJacobiCD"+                               , "InverseJacobiCN"+                               , "InverseJacobiCS"+                               , "InverseJacobiDC"+                               , "InverseJacobiDN"+                               , "InverseJacobiDS"+                               , "InverseJacobiNC"+                               , "InverseJacobiND"+                               , "InverseJacobiNS"+                               , "InverseJacobiSC"+                               , "InverseJacobiSD"+                               , "InverseJacobiSN"+                               , "InverseLaplaceTransform"+                               , "InversePermutation"+                               , "InverseRadon"+                               , "InverseSeries"+                               , "InverseSurvivalFunction"+                               , "InverseWaveletTransform"+                               , "InverseWeierstrassP"+                               , "InverseZTransform"+                               , "Invisible"+                               , "IrreduciblePolynomialQ"+                               , "IsolatingInterval"+                               , "IsomorphicGraphQ"+                               , "IsotopeData"+                               , "Italic"+                               , "Item"+                               , "ItemAspectRatio"+                               , "ItemSize"+                               , "ItemStyle"+                               , "J"+                               , "JaccardDissimilarity"+                               , "JacobiAmplitude"+                               , "JacobiCD"+                               , "JacobiCN"+                               , "JacobiCS"+                               , "JacobiDC"+                               , "JacobiDN"+                               , "JacobiDS"+                               , "JacobiNC"+                               , "JacobiND"+                               , "JacobiNS"+                               , "JacobiP"+                               , "JacobiSC"+                               , "JacobiSD"+                               , "JacobiSN"+                               , "JacobiSymbol"+                               , "JacobiZeta"+                               , "JankoGroupJ1"+                               , "JankoGroupJ2"+                               , "JankoGroupJ3"+                               , "JankoGroupJ4"+                               , "JarqueBeraALMTest"+                               , "JohnsonDistribution"+                               , "Join"+                               , "Joined"+                               , "JoinedCurve"+                               , "JoinForm"+                               , "JordanDecomposition"+                               , "JordanModelDecomposition"+                               , "K"+                               , "KagiChart"+                               , "KalmanEstimator"+                               , "KarhunenLoeveDecomposition"+                               , "KaryTree"+                               , "KatzCentrality"+                               , "KCoreComponents"+                               , "KDistribution"+                               , "KelvinBei"+                               , "KelvinBer"+                               , "KelvinKei"+                               , "KelvinKer"+                               , "KernelMixtureDistribution"+                               , "KernelObject"+                               , "Kernels"+                               , "Khinchin"+                               , "KirchhoffGraph"+                               , "KirchhoffMatrix"+                               , "KleinInvariantJ"+                               , "KnightTourGraph"+                               , "KnotData"+                               , "KolmogorovSmirnovTest"+                               , "KroneckerDelta"+                               , "KroneckerProduct"+                               , "KroneckerSymbol"+                               , "KuiperTest"+                               , "KumaraswamyDistribution"+                               , "Kurtosis"+                               , "KuwaharaFilter"+                               , "L"+                               , "Label"+                               , "Labeled"+                               , "LabelingFunction"+                               , "LabelStyle"+                               , "LaguerreL"+                               , "LandauDistribution"+                               , "LanguageCategory"+                               , "LaplaceDistribution"+                               , "LaplaceTransform"+                               , "LaplacianFilter"+                               , "LaplacianGaussianFilter"+                               , "Large"+                               , "Larger"+                               , "Last"+                               , "Latitude"+                               , "LatitudeLongitude"+                               , "LatticeData"+                               , "LatticeReduce"+                               , "LaunchKernels"+                               , "LayeredGraphPlot"+                               , "LayerSizeFunction"+                               , "LCM"+                               , "LeafCount"+                               , "LeastSquares"+                               , "Left"+                               , "LeftArrow"+                               , "LeftArrowBar"+                               , "LeftArrowRightArrow"+                               , "LeftDownTeeVector"+                               , "LeftDownVector"+                               , "LeftDownVectorBar"+                               , "LeftRightArrow"+                               , "LeftRightVector"+                               , "LeftTeeArrow"+                               , "LeftTeeVector"+                               , "LeftTriangle"+                               , "LeftTriangleBar"+                               , "LeftTriangleEqual"+                               , "LeftUpDownVector"+                               , "LeftUpTeeVector"+                               , "LeftUpVector"+                               , "LeftUpVectorBar"+                               , "LeftVector"+                               , "LeftVectorBar"+                               , "LegendAppearance"+                               , "Legended"+                               , "LegendreP"+                               , "LegendreQ"+                               , "Length"+                               , "LengthWhile"+                               , "LerchPhi"+                               , "Less"+                               , "LessEqual"+                               , "LessEqualGreater"+                               , "LessFullEqual"+                               , "LessGreater"+                               , "LessLess"+                               , "LessSlantEqual"+                               , "LessTilde"+                               , "LetterCharacter"+                               , "LetterQ"+                               , "Level"+                               , "LeveneTest"+                               , "LeviCivitaTensor"+                               , "LevyDistribution"+                               , "LibraryFunction"+                               , "LibraryFunctionError"+                               , "LibraryFunctionInformation"+                               , "LibraryFunctionLoad"+                               , "LibraryFunctionUnload"+                               , "LibraryLoad"+                               , "LibraryUnload"+                               , "LiftingFilterData"+                               , "LiftingWaveletTransform"+                               , "LightBlue"+                               , "LightBrown"+                               , "LightCyan"+                               , "Lighter"+                               , "LightGray"+                               , "LightGreen"+                               , "Lighting"+                               , "LightingAngle"+                               , "LightMagenta"+                               , "LightOrange"+                               , "LightPink"+                               , "LightPurple"+                               , "LightRed"+                               , "LightYellow"+                               , "Likelihood"+                               , "Limit"+                               , "LimitsPositioning"+                               , "LindleyDistribution"+                               , "Line"+                               , "LinearFractionalTransform"+                               , "LinearModelFit"+                               , "LinearOffsetFunction"+                               , "LinearProgramming"+                               , "LinearRecurrence"+                               , "LinearSolve"+                               , "LinearSolveFunction"+                               , "LineBreakChart"+                               , "LineGraph"+                               , "LineIndent"+                               , "LineIndentMaxFraction"+                               , "LineIntegralConvolutionPlot"+                               , "LineIntegralConvolutionScale"+                               , "LineSpacing"+                               , "LinkClose"+                               , "LinkConnect"+                               , "LinkCreate"+                               , "LinkFunction"+                               , "LinkInterrupt"+                               , "LinkLaunch"+                               , "LinkObject"+                               , "LinkPatterns"+                               , "LinkProtocol"+                               , "LinkRead"+                               , "LinkReadyQ"+                               , "Links"+                               , "LinkWrite"+                               , "LiouvilleLambda"+                               , "List"+                               , "Listable"+                               , "ListAnimate"+                               , "ListContourPlot"+                               , "ListContourPlot3D"+                               , "ListConvolve"+                               , "ListCorrelate"+                               , "ListCurvePathPlot"+                               , "ListDeconvolve"+                               , "ListDensityPlot"+                               , "ListInterpolation"+                               , "ListLineIntegralConvolutionPlot"+                               , "ListLinePlot"+                               , "ListLogLinearPlot"+                               , "ListLogLogPlot"+                               , "ListLogPlot"+                               , "ListPlay"+                               , "ListPlot"+                               , "ListPlot3D"+                               , "ListPointPlot3D"+                               , "ListPolarPlot"+                               , "ListStreamDensityPlot"+                               , "ListStreamPlot"+                               , "ListSurfacePlot3D"+                               , "ListVectorDensityPlot"+                               , "ListVectorPlot"+                               , "ListVectorPlot3D"+                               , "LocalizeVariables"+                               , "LocationEquivalenceTest"+                               , "LocationTest"+                               , "Locator"+                               , "LocatorAutoCreate"+                               , "LocatorPane"+                               , "LocatorRegion"+                               , "Locked"+                               , "Log"+                               , "Log10"+                               , "Log2"+                               , "LogBarnesG"+                               , "LogGamma"+                               , "LogGammaDistribution"+                               , "LogicalExpand"+                               , "LogIntegral"+                               , "LogisticDistribution"+                               , "LogitModelFit"+                               , "LogLikelihood"+                               , "LogLinearPlot"+                               , "LogLogisticDistribution"+                               , "LogLogPlot"+                               , "LogNormalDistribution"+                               , "LogPlot"+                               , "LogSeriesDistribution"+                               , "Longest"+                               , "LongestCommonSequence"+                               , "LongestCommonSubsequence"+                               , "Longitude"+                               , "LongLeftArrow"+                               , "LongLeftRightArrow"+                               , "LongRightArrow"+                               , "LoopFreeGraphQ"+                               , "LowerCaseQ"+                               , "LowerLeftArrow"+                               , "LowerRightArrow"+                               , "LowerTriangularize"+                               , "LQEstimatorGains"+                               , "LQGRegulator"+                               , "LQOutputRegulatorGains"+                               , "LQRegulatorGains"+                               , "LucasL"+                               , "LUDecomposition"+                               , "LyapunovSolve"+                               , "LyonsGroupLy"+                               , "M"+                               , "MachineNumberQ"+                               , "MachinePrecision"+                               , "Magenta"+                               , "Magnification"+                               , "Magnify"+                               , "Majority"+                               , "MakeBoxes"+                               , "MakeExpression"+                               , "MangoldtLambda"+                               , "ManhattanDistance"+                               , "Manipulate"+                               , "Manipulator"+                               , "MannWhitneyTest"+                               , "MantissaExponent"+                               , "Manual"+                               , "Map"+                               , "MapAll"+                               , "MapAt"+                               , "MapIndexed"+                               , "MapThread"+                               , "MarcumQ"+                               , "MardiaCombinedTest"+                               , "MardiaKurtosisTest"+                               , "MardiaSkewnessTest"+                               , "MarginalDistribution"+                               , "Masking"+                               , "MatchingDissimilarity"+                               , "MatchLocalNames"+                               , "MatchQ"+                               , "MathieuC"+                               , "MathieuCharacteristicA"+                               , "MathieuCharacteristicB"+                               , "MathieuCharacteristicExponent"+                               , "MathieuCPrime"+                               , "MathieuGroupM11"+                               , "MathieuGroupM12"+                               , "MathieuGroupM22"+                               , "MathieuGroupM23"+                               , "MathieuGroupM24"+                               , "MathieuS"+                               , "MathieuSPrime"+                               , "MathMLForm"+                               , "MatrixExp"+                               , "MatrixForm"+                               , "MatrixPlot"+                               , "MatrixPower"+                               , "MatrixQ"+                               , "MatrixRank"+                               , "Max"+                               , "MaxDetect"+                               , "MaxExtraBandwidths"+                               , "MaxExtraConditions"+                               , "MaxFilter"+                               , "Maximize"+                               , "MaxIterations"+                               , "MaxMemoryUsed"+                               , "MaxMixtureKernels"+                               , "MaxPlotPoints"+                               , "MaxRecursion"+                               , "MaxStableDistribution"+                               , "MaxStepFraction"+                               , "MaxSteps"+                               , "MaxStepSize"+                               , "MaxValue"+                               , "MaxwellDistribution"+                               , "McLaughlinGroupMcL"+                               , "Mean"+                               , "MeanDeviation"+                               , "MeanFilter"+                               , "MeanShift"+                               , "MeanShiftFilter"+                               , "Median"+                               , "MedianDeviation"+                               , "MedianFilter"+                               , "Medium"+                               , "MeijerG"+                               , "MemberQ"+                               , "MemoryConstrained"+                               , "MemoryInUse"+                               , "MenuCommandKey"+                               , "MenuPacket"+                               , "MenuSortingValue"+                               , "MenuStyle"+                               , "MenuView"+                               , "Mesh"+                               , "MeshFunctions"+                               , "MeshShading"+                               , "MeshStyle"+                               , "Message"+                               , "MessageDialog"+                               , "MessageList"+                               , "MessageName"+                               , "MessagePacket"+                               , "Messages"+                               , "Method"+                               , "MexicanHatWavelet"+                               , "MeyerWavelet"+                               , "Min"+                               , "MinDetect"+                               , "MinFilter"+                               , "MinimalPolynomial"+                               , "MinimalStateSpaceModel"+                               , "Minimize"+                               , "Minors"+                               , "MinStableDistribution"+                               , "Minus"+                               , "MinusPlus"+                               , "MinValue"+                               , "Missing"+                               , "MixtureDistribution"+                               , "Mod"+                               , "Modal"+                               , "ModularLambda"+                               , "Module"+                               , "Modulus"+                               , "MoebiusMu"+                               , "Moment"+                               , "MomentConvert"+                               , "MomentEvaluate"+                               , "MomentGeneratingFunction"+                               , "Monitor"+                               , "MonomialList"+                               , "MonsterGroupM"+                               , "MorletWavelet"+                               , "MorphologicalBinarize"+                               , "MorphologicalBranchPoints"+                               , "MorphologicalComponents"+                               , "MorphologicalEulerNumber"+                               , "MorphologicalGraph"+                               , "MorphologicalPerimeter"+                               , "MorphologicalTransform"+                               , "Most"+                               , "MouseAnnotation"+                               , "MouseAppearance"+                               , "Mouseover"+                               , "MousePosition"+                               , "MovingAverage"+                               , "MovingMedian"+                               , "MoyalDistribution"+                               , "MultiedgeStyle"+                               , "Multinomial"+                               , "MultinomialDistribution"+                               , "MultinormalDistribution"+                               , "MultiplicativeOrder"+                               , "MultivariateHypergeometricDistribution"+                               , "MultivariatePoissonDistribution"+                               , "MultivariateTDistribution"+                               , "N"+                               , "NakagamiDistribution"+                               , "NameQ"+                               , "Names"+                               , "Nand"+                               , "NArgMax"+                               , "NArgMin"+                               , "NCache"+                               , "NDSolve"+                               , "Nearest"+                               , "NearestFunction"+                               , "NeedlemanWunschSimilarity"+                               , "Needs"+                               , "Negative"+                               , "NegativeBinomialDistribution"+                               , "NegativeMultinomialDistribution"+                               , "NeighborhoodGraph"+                               , "Nest"+                               , "NestedGreaterGreater"+                               , "NestedLessLess"+                               , "NestList"+                               , "NestWhile"+                               , "NestWhileList"+                               , "NevilleThetaC"+                               , "NevilleThetaD"+                               , "NevilleThetaN"+                               , "NevilleThetaS"+                               , "NExpectation"+                               , "NextPrime"+                               , "NHoldAll"+                               , "NHoldFirst"+                               , "NHoldRest"+                               , "NicholsGridLines"+                               , "NicholsPlot"+                               , "NIntegrate"+                               , "NMaximize"+                               , "NMaxValue"+                               , "NMinimize"+                               , "NMinValue"+                               , "NominalVariables"+                               , "NoncentralBetaDistribution"+                               , "NoncentralChiSquareDistribution"+                               , "NoncentralFRatioDistribution"+                               , "NoncentralStudentTDistribution"+                               , "NonCommutativeMultiply"+                               , "NonConstants"+                               , "None"+                               , "NonlinearModelFit"+                               , "NonNegative"+                               , "NonPositive"+                               , "Nor"+                               , "NorlundB"+                               , "Norm"+                               , "Normal"+                               , "NormalDistribution"+                               , "Normalize"+                               , "NormalizedSquaredEuclideanDistance"+                               , "NormalsFunction"+                               , "NormFunction"+                               , "Not"+                               , "NotCongruent"+                               , "NotCupCap"+                               , "NotDoubleVerticalBar"+                               , "Notebook"+                               , "NotebookApply"+                               , "NotebookAutoSave"+                               , "NotebookClose"+                               , "NotebookDelete"+                               , "NotebookDirectory"+                               , "NotebookDynamicExpression"+                               , "NotebookEvaluate"+                               , "NotebookEventActions"+                               , "NotebookFileName"+                               , "NotebookFind"+                               , "NotebookGet"+                               , "NotebookInformation"+                               , "NotebookLocate"+                               , "NotebookObject"+                               , "NotebookOpen"+                               , "NotebookPrint"+                               , "NotebookPut"+                               , "NotebookRead"+                               , "Notebooks"+                               , "NotebookSave"+                               , "NotebookSelection"+                               , "NotebookWrite"+                               , "NotElement"+                               , "NotEqualTilde"+                               , "NotExists"+                               , "NotGreater"+                               , "NotGreaterEqual"+                               , "NotGreaterFullEqual"+                               , "NotGreaterGreater"+                               , "NotGreaterLess"+                               , "NotGreaterSlantEqual"+                               , "NotGreaterTilde"+                               , "NotHumpDownHump"+                               , "NotHumpEqual"+                               , "NotLeftTriangle"+                               , "NotLeftTriangleBar"+                               , "NotLeftTriangleEqual"+                               , "NotLess"+                               , "NotLessEqual"+                               , "NotLessFullEqual"+                               , "NotLessGreater"+                               , "NotLessLess"+                               , "NotLessSlantEqual"+                               , "NotLessTilde"+                               , "NotNestedGreaterGreater"+                               , "NotNestedLessLess"+                               , "NotPrecedes"+                               , "NotPrecedesEqual"+                               , "NotPrecedesSlantEqual"+                               , "NotPrecedesTilde"+                               , "NotReverseElement"+                               , "NotRightTriangle"+                               , "NotRightTriangleBar"+                               , "NotRightTriangleEqual"+                               , "NotSquareSubset"+                               , "NotSquareSubsetEqual"+                               , "NotSquareSuperset"+                               , "NotSquareSupersetEqual"+                               , "NotSubset"+                               , "NotSubsetEqual"+                               , "NotSucceeds"+                               , "NotSucceedsEqual"+                               , "NotSucceedsSlantEqual"+                               , "NotSucceedsTilde"+                               , "NotSuperset"+                               , "NotSupersetEqual"+                               , "NotTilde"+                               , "NotTildeEqual"+                               , "NotTildeFullEqual"+                               , "NotTildeTilde"+                               , "NotVerticalBar"+                               , "NProbability"+                               , "NProduct"+                               , "NRoots"+                               , "NSolve"+                               , "NSum"+                               , "Null"+                               , "NullRecords"+                               , "NullSpace"+                               , "NullWords"+                               , "Number"+                               , "NumberFieldClassNumber"+                               , "NumberFieldDiscriminant"+                               , "NumberFieldFundamentalUnits"+                               , "NumberFieldIntegralBasis"+                               , "NumberFieldNormRepresentatives"+                               , "NumberFieldRegulator"+                               , "NumberFieldRootsOfUnity"+                               , "NumberFieldSignature"+                               , "NumberForm"+                               , "NumberFormat"+                               , "NumberMarks"+                               , "NumberMultiplier"+                               , "NumberPadding"+                               , "NumberPoint"+                               , "NumberQ"+                               , "NumberSeparator"+                               , "NumberSigns"+                               , "NumberString"+                               , "Numerator"+                               , "NumericFunction"+                               , "NumericQ"+                               , "NyquistGridLines"+                               , "NyquistPlot"+                               , "O"+                               , "ObservabilityGramian"+                               , "ObservabilityMatrix"+                               , "ObservableDecomposition"+                               , "ObservableModelQ"+                               , "OddQ"+                               , "Off"+                               , "Offset"+                               , "On"+                               , "ONanGroupON"+                               , "OneIdentity"+                               , "Opacity"+                               , "OpenAppend"+                               , "Opener"+                               , "OpenerView"+                               , "Opening"+                               , "OpenRead"+                               , "OpenWrite"+                               , "Operate"+                               , "OperatingSystem"+                               , "Optional"+                               , "Options"+                               , "OptionsPattern"+                               , "OptionValue"+                               , "Or"+                               , "Orange"+                               , "Order"+                               , "OrderDistribution"+                               , "OrderedQ"+                               , "Ordering"+                               , "Orderless"+                               , "Orthogonalize"+                               , "Out"+                               , "Outer"+                               , "OutputControllabilityMatrix"+                               , "OutputControllableModelQ"+                               , "OutputForm"+                               , "OutputNamePacket"+                               , "OutputResponse"+                               , "OutputSizeLimit"+                               , "OutputStream"+                               , "OverBar"+                               , "OverDot"+                               , "Overflow"+                               , "OverHat"+                               , "Overlaps"+                               , "Overlay"+                               , "Overscript"+                               , "OverscriptBox"+                               , "OverTilde"+                               , "OverVector"+                               , "OwenT"+                               , "OwnValues"+                               , "P"+                               , "PackingMethod"+                               , "PaddedForm"+                               , "Padding"+                               , "PadeApproximant"+                               , "PadLeft"+                               , "PadRight"+                               , "PageBreakAbove"+                               , "PageBreakBelow"+                               , "PageBreakWithin"+                               , "PageFooters"+                               , "PageHeaders"+                               , "PageRankCentrality"+                               , "PageWidth"+                               , "PairedBarChart"+                               , "PairedHistogram"+                               , "PairedTTest"+                               , "PairedZTest"+                               , "PaletteNotebook"+                               , "Pane"+                               , "Panel"+                               , "Paneled"+                               , "PaneSelector"+                               , "ParabolicCylinderD"+                               , "ParagraphIndent"+                               , "ParagraphSpacing"+                               , "ParallelArray"+                               , "ParallelCombine"+                               , "ParallelDo"+                               , "ParallelEvaluate"+                               , "Parallelization"+                               , "Parallelize"+                               , "ParallelMap"+                               , "ParallelNeeds"+                               , "ParallelProduct"+                               , "ParallelSubmit"+                               , "ParallelSum"+                               , "ParallelTable"+                               , "ParallelTry"+                               , "ParameterEstimator"+                               , "ParameterMixtureDistribution"+                               , "ParametricPlot"+                               , "ParametricPlot3D"+                               , "ParentDirectory"+                               , "ParetoDistribution"+                               , "Part"+                               , "ParticleData"+                               , "Partition"+                               , "PartitionsP"+                               , "PartitionsQ"+                               , "PascalDistribution"+                               , "PassEventsDown"+                               , "PassEventsUp"+                               , "Paste"+                               , "PasteButton"+                               , "Path"+                               , "PathGraph"+                               , "PathGraphQ"+                               , "Pattern"+                               , "PatternSequence"+                               , "PatternTest"+                               , "PauliMatrix"+                               , "PaulWavelet"+                               , "Pause"+                               , "PDF"+                               , "PearsonChiSquareTest"+                               , "PearsonDistribution"+                               , "PerformanceGoal"+                               , "PermutationCycles"+                               , "PermutationCyclesQ"+                               , "PermutationGroup"+                               , "PermutationLength"+                               , "PermutationList"+                               , "PermutationListQ"+                               , "PermutationMax"+                               , "PermutationMin"+                               , "PermutationOrder"+                               , "PermutationPower"+                               , "PermutationProduct"+                               , "PermutationReplace"+                               , "Permutations"+                               , "PermutationSupport"+                               , "Permute"+                               , "PeronaMalikFilter"+                               , "PERTDistribution"+                               , "PetersenGraph"+                               , "PhaseMargins"+                               , "Pi"+                               , "Pick"+                               , "Piecewise"+                               , "PiecewiseExpand"+                               , "PieChart"+                               , "PieChart3D"+                               , "Pink"+                               , "PixelConstrained"+                               , "PixelValue"+                               , "Placed"+                               , "Placeholder"+                               , "PlaceholderReplace"+                               , "Plain"+                               , "Play"+                               , "PlayRange"+                               , "Plot"+                               , "Plot3D"+                               , "PlotLabel"+                               , "PlotLayout"+                               , "PlotMarkers"+                               , "PlotPoints"+                               , "PlotRange"+                               , "PlotRangeClipping"+                               , "PlotRangePadding"+                               , "PlotRegion"+                               , "PlotStyle"+                               , "Plus"+                               , "PlusMinus"+                               , "Pochhammer"+                               , "PodStates"+                               , "PodWidth"+                               , "Point"+                               , "PointFigureChart"+                               , "PointSize"+                               , "PoissonConsulDistribution"+                               , "PoissonDistribution"+                               , "PolarAxes"+                               , "PolarAxesOrigin"+                               , "PolarGridLines"+                               , "PolarPlot"+                               , "PolarTicks"+                               , "PoleZeroMarkers"+                               , "PolyaAeppliDistribution"+                               , "PolyGamma"+                               , "Polygon"+                               , "PolyhedronData"+                               , "PolyLog"+                               , "PolynomialExtendedGCD"+                               , "PolynomialGCD"+                               , "PolynomialLCM"+                               , "PolynomialMod"+                               , "PolynomialQ"+                               , "PolynomialQuotient"+                               , "PolynomialQuotientRemainder"+                               , "PolynomialReduce"+                               , "PolynomialRemainder"+                               , "PopupMenu"+                               , "PopupView"+                               , "PopupWindow"+                               , "Position"+                               , "Positive"+                               , "PositiveDefiniteMatrixQ"+                               , "PossibleZeroQ"+                               , "Postfix"+                               , "Power"+                               , "PowerDistribution"+                               , "PowerExpand"+                               , "PowerMod"+                               , "PowerModList"+                               , "PowersRepresentations"+                               , "PowerSymmetricPolynomial"+                               , "PrecedenceForm"+                               , "Precedes"+                               , "PrecedesEqual"+                               , "PrecedesSlantEqual"+                               , "PrecedesTilde"+                               , "Precision"+                               , "PrecisionGoal"+                               , "PreDecrement"+                               , "PreemptProtect"+                               , "Prefix"+                               , "PreIncrement"+                               , "Prepend"+                               , "PrependTo"+                               , "PreserveImageOptions"+                               , "PriceGraphDistribution"+                               , "Prime"+                               , "PrimeNu"+                               , "PrimeOmega"+                               , "PrimePi"+                               , "PrimePowerQ"+                               , "PrimeQ"+                               , "Primes"+                               , "PrimeZetaP"+                               , "PrimitiveRoot"+                               , "PrincipalComponents"+                               , "PrincipalValue"+                               , "Print"+                               , "PrintingStyleEnvironment"+                               , "PrintTemporary"+                               , "Probability"+                               , "ProbabilityDistribution"+                               , "ProbabilityPlot"+                               , "ProbabilityScalePlot"+                               , "ProbitModelFit"+                               , "Product"+                               , "ProductDistribution"+                               , "ProductLog"+                               , "ProgressIndicator"+                               , "Projection"+                               , "Prolog"+                               , "Properties"+                               , "Property"+                               , "PropertyList"+                               , "PropertyValue"+                               , "Proportion"+                               , "Proportional"+                               , "Protect"+                               , "Protected"+                               , "ProteinData"+                               , "Pruning"+                               , "PseudoInverse"+                               , "Purple"+                               , "Put"+                               , "PutAppend"+                               , "Q"+                               , "QBinomial"+                               , "QFactorial"+                               , "QGamma"+                               , "QHypergeometricPFQ"+                               , "QPochhammer"+                               , "QPolyGamma"+                               , "QRDecomposition"+                               , "QuadraticIrrationalQ"+                               , "Quantile"+                               , "QuantilePlot"+                               , "Quartics"+                               , "QuartileDeviation"+                               , "Quartiles"+                               , "QuartileSkewness"+                               , "Quiet"+                               , "Quit"+                               , "Quotient"+                               , "QuotientRemainder"+                               , "R"+                               , "RadicalBox"+                               , "RadioButton"+                               , "RadioButtonBar"+                               , "Radon"+                               , "RamanujanTau"+                               , "RamanujanTauL"+                               , "RamanujanTauTheta"+                               , "RamanujanTauZ"+                               , "RandomChoice"+                               , "RandomComplex"+                               , "RandomGraph"+                               , "RandomImage"+                               , "RandomInteger"+                               , "RandomPermutation"+                               , "RandomPrime"+                               , "RandomReal"+                               , "RandomSample"+                               , "RandomVariate"+                               , "Range"+                               , "RangeFilter"+                               , "RankedMax"+                               , "RankedMin"+                               , "Raster"+                               , "Rasterize"+                               , "RasterSize"+                               , "Rational"+                               , "Rationalize"+                               , "Rationals"+                               , "Ratios"+                               , "RawBoxes"+                               , "RawData"+                               , "RayleighDistribution"+                               , "Re"+                               , "Read"+                               , "ReadList"+                               , "ReadProtected"+                               , "Real"+                               , "RealBlockDiagonalForm"+                               , "RealDigits"+                               , "RealExponent"+                               , "Reals"+                               , "Reap"+                               , "Record"+                               , "RecordLists"+                               , "RecordSeparators"+                               , "Rectangle"+                               , "RectangleChart"+                               , "RectangleChart3D"+                               , "RecurrenceTable"+                               , "Red"+                               , "Reduce"+                               , "ReferenceLineStyle"+                               , "Refine"+                               , "ReflectionMatrix"+                               , "ReflectionTransform"+                               , "Refresh"+                               , "RefreshRate"+                               , "RegionBinarize"+                               , "RegionFunction"+                               , "RegionPlot"+                               , "RegionPlot3D"+                               , "RegularExpression"+                               , "Regularization"+                               , "ReleaseHold"+                               , "ReliefImage"+                               , "ReliefPlot"+                               , "Remove"+                               , "RemoveAlphaChannel"+                               , "RemoveProperty"+                               , "RemoveScheduledTask"+                               , "RenameDirectory"+                               , "RenameFile"+                               , "RenkoChart"+                               , "Repeated"+                               , "RepeatedNull"+                               , "Replace"+                               , "ReplaceAll"+                               , "ReplaceList"+                               , "ReplacePart"+                               , "ReplaceRepeated"+                               , "Resampling"+                               , "Rescale"+                               , "RescalingTransform"+                               , "ResetDirectory"+                               , "ResetScheduledTask"+                               , "Residue"+                               , "Resolve"+                               , "Rest"+                               , "Resultant"+                               , "ResumePacket"+                               , "Return"+                               , "ReturnExpressionPacket"+                               , "ReturnPacket"+                               , "ReturnTextPacket"+                               , "Reverse"+                               , "ReverseBiorthogonalSplineWavelet"+                               , "ReverseElement"+                               , "ReverseEquilibrium"+                               , "ReverseGraph"+                               , "ReverseUpEquilibrium"+                               , "RevolutionAxis"+                               , "RevolutionPlot3D"+                               , "RGBColor"+                               , "RiccatiSolve"+                               , "RiceDistribution"+                               , "RidgeFilter"+                               , "RiemannR"+                               , "RiemannSiegelTheta"+                               , "RiemannSiegelZ"+                               , "Riffle"+                               , "Right"+                               , "RightArrow"+                               , "RightArrowBar"+                               , "RightArrowLeftArrow"+                               , "RightCosetRepresentative"+                               , "RightDownTeeVector"+                               , "RightDownVector"+                               , "RightDownVectorBar"+                               , "RightTeeArrow"+                               , "RightTeeVector"+                               , "RightTriangle"+                               , "RightTriangleBar"+                               , "RightTriangleEqual"+                               , "RightUpDownVector"+                               , "RightUpTeeVector"+                               , "RightUpVector"+                               , "RightUpVectorBar"+                               , "RightVector"+                               , "RightVectorBar"+                               , "RogersTanimotoDissimilarity"+                               , "Root"+                               , "RootApproximant"+                               , "RootIntervals"+                               , "RootLocusPlot"+                               , "RootMeanSquare"+                               , "RootOfUnityQ"+                               , "RootReduce"+                               , "Roots"+                               , "RootSum"+                               , "Rotate"+                               , "RotateLabel"+                               , "RotateLeft"+                               , "RotateRight"+                               , "RotationAction"+                               , "RotationMatrix"+                               , "RotationTransform"+                               , "Round"+                               , "RoundingRadius"+                               , "Row"+                               , "RowAlignments"+                               , "RowBox"+                               , "RowLines"+                               , "RowMinHeight"+                               , "RowReduce"+                               , "RowsEqual"+                               , "RowSpacings"+                               , "RSolve"+                               , "RudvalisGroupRu"+                               , "Rule"+                               , "RuleDelayed"+                               , "Run"+                               , "RunScheduledTask"+                               , "RunThrough"+                               , "RuntimeAttributes"+                               , "RuntimeOptions"+                               , "RussellRaoDissimilarity"+                               , "S"+                               , "SameQ"+                               , "SameTest"+                               , "SampleDepth"+                               , "SampledSoundFunction"+                               , "SampledSoundList"+                               , "SampleRate"+                               , "SamplingPeriod"+                               , "SatisfiabilityCount"+                               , "SatisfiabilityInstances"+                               , "SatisfiableQ"+                               , "Save"+                               , "SaveDefinitions"+                               , "SawtoothWave"+                               , "Scale"+                               , "Scaled"+                               , "ScalingFunctions"+                               , "ScalingMatrix"+                               , "ScalingTransform"+                               , "Scan"+                               , "ScheduledTaskObject"+                               , "ScheduledTasks"+                               , "SchurDecomposition"+                               , "ScientificForm"+                               , "ScreenStyleEnvironment"+                               , "ScriptBaselineShifts"+                               , "ScriptMinSize"+                               , "ScriptSizeMultipliers"+                               , "Scrollbars"+                               , "ScrollPosition"+                               , "Sec"+                               , "Sech"+                               , "SechDistribution"+                               , "SectorChart"+                               , "SectorChart3D"+                               , "SectorOrigin"+                               , "SectorSpacing"+                               , "SeedRandom"+                               , "Select"+                               , "Selectable"+                               , "SelectComponents"+                               , "SelectedNotebook"+                               , "SelectionAnimate"+                               , "SelectionCreateCell"+                               , "SelectionEvaluate"+                               , "SelectionEvaluateCreateCell"+                               , "SelectionMove"+                               , "SelfLoopStyle"+                               , "SemialgebraicComponentInstances"+                               , "SendMail"+                               , "Sequence"+                               , "SequenceAlignment"+                               , "SequenceHold"+                               , "Series"+                               , "SeriesCoefficient"+                               , "SeriesData"+                               , "SessionTime"+                               , "Set"+                               , "SetAccuracy"+                               , "SetAlphaChannel"+                               , "SetAttributes"+                               , "SetDelayed"+                               , "SetDirectory"+                               , "SetFileDate"+                               , "SetOptions"+                               , "SetPrecision"+                               , "SetProperty"+                               , "SetSelectedNotebook"+                               , "SetSharedFunction"+                               , "SetSharedVariable"+                               , "SetStreamPosition"+                               , "SetSystemOptions"+                               , "Setter"+                               , "SetterBar"+                               , "Setting"+                               , "Shallow"+                               , "ShannonWavelet"+                               , "ShapiroWilkTest"+                               , "Share"+                               , "Sharpen"+                               , "ShearingMatrix"+                               , "ShearingTransform"+                               , "Short"+                               , "ShortDownArrow"+                               , "Shortest"+                               , "ShortestPathFunction"+                               , "ShortLeftArrow"+                               , "ShortRightArrow"+                               , "ShortUpArrow"+                               , "Show"+                               , "ShowAutoStyles"+                               , "ShowCellBracket"+                               , "ShowCellLabel"+                               , "ShowCellTags"+                               , "ShowCursorTracker"+                               , "ShowGroupOpener"+                               , "ShowPageBreaks"+                               , "ShowSelection"+                               , "ShowSpecialCharacters"+                               , "ShowStringCharacters"+                               , "ShrinkingDelay"+                               , "SiegelTheta"+                               , "SiegelTukeyTest"+                               , "Sign"+                               , "Signature"+                               , "SignedRankTest"+                               , "SignificanceLevel"+                               , "SignPadding"+                               , "SignTest"+                               , "SimilarityRules"+                               , "SimpleGraph"+                               , "SimpleGraphQ"+                               , "Simplify"+                               , "Sin"+                               , "Sinc"+                               , "SinghMaddalaDistribution"+                               , "SingleLetterItalics"+                               , "SingularValueDecomposition"+                               , "SingularValueList"+                               , "SingularValuePlot"+                               , "Sinh"+                               , "SinhIntegral"+                               , "SinIntegral"+                               , "SixJSymbol"+                               , "Skeleton"+                               , "SkeletonTransform"+                               , "SkellamDistribution"+                               , "Skewness"+                               , "SkewNormalDistribution"+                               , "Skip"+                               , "Slider"+                               , "Slider2D"+                               , "SlideView"+                               , "Slot"+                               , "SlotSequence"+                               , "Small"+                               , "SmallCircle"+                               , "Smaller"+                               , "SmithWatermanSimilarity"+                               , "SmoothDensityHistogram"+                               , "SmoothHistogram"+                               , "SmoothHistogram3D"+                               , "SmoothKernelDistribution"+                               , "SokalSneathDissimilarity"+                               , "Solve"+                               , "SolveAlways"+                               , "Sort"+                               , "SortBy"+                               , "Sound"+                               , "SoundNote"+                               , "SoundVolume"+                               , "Sow"+                               , "Spacer"+                               , "Spacings"+                               , "Span"+                               , "SpanFromAbove"+                               , "SpanFromBoth"+                               , "SpanFromLeft"+                               , "SparseArray"+                               , "Speak"+                               , "Specularity"+                               , "SpellingCorrection"+                               , "Sphere"+                               , "SphericalBesselJ"+                               , "SphericalBesselY"+                               , "SphericalHankelH1"+                               , "SphericalHankelH2"+                               , "SphericalHarmonicY"+                               , "SphericalPlot3D"+                               , "SphericalRegion"+                               , "SpheroidalEigenvalue"+                               , "SpheroidalJoiningFactor"+                               , "SpheroidalPS"+                               , "SpheroidalPSPrime"+                               , "SpheroidalQS"+                               , "SpheroidalQSPrime"+                               , "SpheroidalRadialFactor"+                               , "SpheroidalS1"+                               , "SpheroidalS1Prime"+                               , "SpheroidalS2"+                               , "SpheroidalS2Prime"+                               , "Splice"+                               , "SplineClosed"+                               , "SplineDegree"+                               , "SplineKnots"+                               , "SplineWeights"+                               , "Split"+                               , "SplitBy"+                               , "SpokenString"+                               , "Sqrt"+                               , "SqrtBox"+                               , "Square"+                               , "SquaredEuclideanDistance"+                               , "SquareFreeQ"+                               , "SquareIntersection"+                               , "SquaresR"+                               , "SquareSubset"+                               , "SquareSubsetEqual"+                               , "SquareSuperset"+                               , "SquareSupersetEqual"+                               , "SquareUnion"+                               , "SquareWave"+                               , "StabilityMargins"+                               , "StabilityMarginsStyle"+                               , "StableDistribution"+                               , "Stack"+                               , "StackBegin"+                               , "StackComplete"+                               , "StackInhibit"+                               , "StandardDeviation"+                               , "StandardDeviationFilter"+                               , "StandardForm"+                               , "Standardize"+                               , "Star"+                               , "StarGraph"+                               , "StartingStepSize"+                               , "StartOfLine"+                               , "StartOfString"+                               , "StartScheduledTask"+                               , "StateFeedbackGains"+                               , "StateOutputEstimator"+                               , "StateResponse"+                               , "StateSpaceModel"+                               , "StateSpaceRealization"+                               , "StateSpaceTransform"+                               , "StationaryWaveletPacketTransform"+                               , "StationaryWaveletTransform"+                               , "StatusArea"+                               , "StepMonitor"+                               , "StieltjesGamma"+                               , "StirlingS1"+                               , "StirlingS2"+                               , "StopScheduledTask"+                               , "StreamColorFunction"+                               , "StreamColorFunctionScaling"+                               , "StreamDensityPlot"+                               , "StreamPlot"+                               , "StreamPoints"+                               , "StreamPosition"+                               , "Streams"+                               , "StreamScale"+                               , "StreamStyle"+                               , "String"+                               , "StringCases"+                               , "StringCount"+                               , "StringDrop"+                               , "StringExpression"+                               , "StringForm"+                               , "StringFormat"+                               , "StringFreeQ"+                               , "StringInsert"+                               , "StringJoin"+                               , "StringLength"+                               , "StringMatchQ"+                               , "StringPosition"+                               , "StringQ"+                               , "StringReplace"+                               , "StringReplaceList"+                               , "StringReplacePart"+                               , "StringReverse"+                               , "StringSkeleton"+                               , "StringSplit"+                               , "StringTake"+                               , "StringToStream"+                               , "StringTrim"+                               , "StructuredSelection"+                               , "StruveH"+                               , "StruveL"+                               , "Stub"+                               , "StudentTDistribution"+                               , "Style"+                               , "StyleBox"+                               , "StyleData"+                               , "StyleDefinitions"+                               , "Subfactorial"+                               , "Subgraph"+                               , "SubMinus"+                               , "SubPlus"+                               , "Subresultants"+                               , "Subscript"+                               , "SubscriptBox"+                               , "Subset"+                               , "SubsetEqual"+                               , "Subsets"+                               , "SubStar"+                               , "Subsuperscript"+                               , "SubsuperscriptBox"+                               , "Subtract"+                               , "SubtractFrom"+                               , "Succeeds"+                               , "SucceedsEqual"+                               , "SucceedsSlantEqual"+                               , "SucceedsTilde"+                               , "SuchThat"+                               , "Sum"+                               , "SumConvergence"+                               , "SuperDagger"+                               , "SuperMinus"+                               , "SuperPlus"+                               , "Superscript"+                               , "SuperscriptBox"+                               , "Superset"+                               , "SupersetEqual"+                               , "SuperStar"+                               , "SurvivalDistribution"+                               , "SurvivalFunction"+                               , "SuspendPacket"+                               , "SuzukiDistribution"+                               , "SuzukiGroupSuz"+                               , "Switch"+                               , "Symbol"+                               , "SymbolName"+                               , "SymletWavelet"+                               , "SymmetricGroup"+                               , "SymmetricMatrixQ"+                               , "SymmetricPolynomial"+                               , "SymmetricReduction"+                               , "SynchronousInitialization"+                               , "SynchronousUpdating"+                               , "SyntaxInformation"+                               , "SyntaxLength"+                               , "SyntaxPacket"+                               , "SyntaxQ"+                               , "SystemDialogInput"+                               , "SystemInformation"+                               , "SystemOpen"+                               , "SystemOptions"+                               , "SystemsModelDelete"+                               , "SystemsModelDimensions"+                               , "SystemsModelExtract"+                               , "SystemsModelFeedbackConnect"+                               , "SystemsModelLabels"+                               , "SystemsModelOrder"+                               , "SystemsModelParallelConnect"+                               , "SystemsModelSeriesConnect"+                               , "SystemsModelStateFeedbackConnect"+                               , "T"+                               , "Table"+                               , "TableAlignments"+                               , "TableDepth"+                               , "TableDirections"+                               , "TableForm"+                               , "TableHeadings"+                               , "TableSpacing"+                               , "TabView"+                               , "TagBox"+                               , "TaggingRules"+                               , "TagSet"+                               , "TagSetDelayed"+                               , "TagUnset"+                               , "Take"+                               , "TakeWhile"+                               , "Tally"+                               , "Tan"+                               , "Tanh"+                               , "TargetFunctions"+                               , "TautologyQ"+                               , "Temporary"+                               , "TeXForm"+                               , "Text"+                               , "TextAlignment"+                               , "TextCell"+                               , "TextClipboardType"+                               , "TextData"+                               , "TextJustification"+                               , "TextPacket"+                               , "TextRecognize"+                               , "Texture"+                               , "TextureCoordinateFunction"+                               , "TextureCoordinateScaling"+                               , "Therefore"+                               , "Thick"+                               , "Thickness"+                               , "Thin"+                               , "Thinning"+                               , "ThompsonGroupTh"+                               , "Thread"+                               , "ThreeJSymbol"+                               , "Threshold"+                               , "Through"+                               , "Throw"+                               , "Thumbnail"+                               , "Ticks"+                               , "TicksStyle"+                               , "Tilde"+                               , "TildeEqual"+                               , "TildeFullEqual"+                               , "TildeTilde"+                               , "TimeConstrained"+                               , "TimeConstraint"+                               , "Times"+                               , "TimesBy"+                               , "TimeUsed"+                               , "TimeValue"+                               , "TimeZone"+                               , "Timing"+                               , "Tiny"+                               , "TitsGroupT"+                               , "ToBoxes"+                               , "ToCharacterCode"+                               , "ToContinuousTimeModel"+                               , "ToDiscreteTimeModel"+                               , "ToeplitzMatrix"+                               , "ToExpression"+                               , "Together"+                               , "Toggler"+                               , "TogglerBar"+                               , "TokenWords"+                               , "Tolerance"+                               , "ToLowerCase"+                               , "ToNumberField"+                               , "Tooltip"+                               , "TooltipDelay"+                               , "Top"+                               , "TopHatTransform"+                               , "TopologicalSort"+                               , "ToRadicals"+                               , "ToRules"+                               , "ToString"+                               , "Total"+                               , "TotalVariationFilter"+                               , "TotalWidth"+                               , "ToUpperCase"+                               , "Tr"+                               , "Trace"+                               , "TraceAbove"+                               , "TraceBackward"+                               , "TraceDepth"+                               , "TraceDialog"+                               , "TraceForward"+                               , "TraceOff"+                               , "TraceOn"+                               , "TraceOriginal"+                               , "TracePrint"+                               , "TraceScan"+                               , "TrackedSymbols"+                               , "TradingChart"+                               , "TraditionalForm"+                               , "TransferFunctionCancel"+                               , "TransferFunctionExpand"+                               , "TransferFunctionFactor"+                               , "TransferFunctionModel"+                               , "TransferFunctionPoles"+                               , "TransferFunctionZeros"+                               , "TransformationFunction"+                               , "TransformationFunctions"+                               , "TransformationMatrix"+                               , "TransformedDistribution"+                               , "Translate"+                               , "TranslationTransform"+                               , "Transparent"+                               , "Transpose"+                               , "TreeForm"+                               , "TreeGraph"+                               , "TreeGraphQ"+                               , "TreePlot"+                               , "TrendStyle"+                               , "TriangleWave"+                               , "TriangularDistribution"+                               , "Trig"+                               , "TrigExpand"+                               , "TrigFactor"+                               , "TrigFactorList"+                               , "Trigger"+                               , "TrigReduce"+                               , "TrigToExp"+                               , "TrimmedMean"+                               , "True"+                               , "TrueQ"+                               , "TruncatedDistribution"+                               , "TTest"+                               , "Tube"+                               , "TukeyLambdaDistribution"+                               , "Tuples"+                               , "TuranGraph"+                               , "TuringMachine"+                               , "U"+                               , "Uncompress"+                               , "Undefined"+                               , "UnderBar"+                               , "Underflow"+                               , "Underlined"+                               , "Underoverscript"+                               , "UnderoverscriptBox"+                               , "Underscript"+                               , "UnderscriptBox"+                               , "UndirectedEdge"+                               , "UndirectedGraph"+                               , "UndirectedGraphQ"+                               , "Unequal"+                               , "Unevaluated"+                               , "UniformDistribution"+                               , "UniformGraphDistribution"+                               , "UniformSumDistribution"+                               , "Uninstall"+                               , "Union"+                               , "UnionPlus"+                               , "Unique"+                               , "UnitBox"+                               , "Unitize"+                               , "UnitStep"+                               , "UnitTriangle"+                               , "UnitVector"+                               , "Unprotect"+                               , "UnsameQ"+                               , "UnsavedVariables"+                               , "Unset"+                               , "UnsetShared"+                               , "UpArrow"+                               , "UpArrowBar"+                               , "UpArrowDownArrow"+                               , "Update"+                               , "UpdateInterval"+                               , "UpDownArrow"+                               , "UpEquilibrium"+                               , "UpperCaseQ"+                               , "UpperLeftArrow"+                               , "UpperRightArrow"+                               , "UpperTriangularize"+                               , "UpSet"+                               , "UpSetDelayed"+                               , "UpTeeArrow"+                               , "UpValues"+                               , "UsingFrontEnd"+                               , "V"+                               , "ValidationLength"+                               , "ValueQ"+                               , "Variables"+                               , "Variance"+                               , "VarianceEquivalenceTest"+                               , "VarianceEstimatorFunction"+                               , "VarianceTest"+                               , "VectorAngle"+                               , "VectorColorFunction"+                               , "VectorColorFunctionScaling"+                               , "VectorDensityPlot"+                               , "VectorPlot"+                               , "VectorPlot3D"+                               , "VectorPoints"+                               , "VectorQ"+                               , "VectorScale"+                               , "VectorStyle"+                               , "Vee"+                               , "Verbatim"+                               , "VerifyConvergence"+                               , "VerifyTestAssumptions"+                               , "VertexAdd"+                               , "VertexColors"+                               , "VertexComponent"+                               , "VertexCoordinateRules"+                               , "VertexCoordinates"+                               , "VertexCount"+                               , "VertexCoverQ"+                               , "VertexDegree"+                               , "VertexDelete"+                               , "VertexEccentricity"+                               , "VertexInComponent"+                               , "VertexInDegree"+                               , "VertexIndex"+                               , "VertexLabeling"+                               , "VertexLabels"+                               , "VertexList"+                               , "VertexNormals"+                               , "VertexOutComponent"+                               , "VertexOutDegree"+                               , "VertexQ"+                               , "VertexRenderingFunction"+                               , "VertexReplace"+                               , "VertexShape"+                               , "VertexShapeFunction"+                               , "VertexSize"+                               , "VertexStyle"+                               , "VertexTextureCoordinates"+                               , "VertexWeight"+                               , "VerticalBar"+                               , "VerticalSeparator"+                               , "VerticalSlider"+                               , "VerticalTilde"+                               , "ViewAngle"+                               , "ViewCenter"+                               , "ViewMatrix"+                               , "ViewPoint"+                               , "ViewRange"+                               , "ViewVector"+                               , "ViewVertical"+                               , "Visible"+                               , "VonMisesDistribution"+                               , "W"+                               , "WaitAll"+                               , "WaitNext"+                               , "WakebyDistribution"+                               , "WalleniusHypergeometricDistribution"+                               , "WaringYuleDistribution"+                               , "WatershedComponents"+                               , "WatsonUSquareTest"+                               , "WattsStrogatzGraphDistribution"+                               , "WaveletBestBasis"+                               , "WaveletFilterCoefficients"+                               , "WaveletImagePlot"+                               , "WaveletListPlot"+                               , "WaveletMapIndexed"+                               , "WaveletMatrixPlot"+                               , "WaveletPhi"+                               , "WaveletPsi"+                               , "WaveletScale"+                               , "WaveletScalogram"+                               , "WaveletThreshold"+                               , "WeatherData"+                               , "WeberE"+                               , "Wedge"+                               , "WeibullDistribution"+                               , "WeierstrassHalfPeriods"+                               , "WeierstrassInvariants"+                               , "WeierstrassP"+                               , "WeierstrassPPrime"+                               , "WeierstrassSigma"+                               , "WeierstrassZeta"+                               , "WeightedAdjacencyGraph"+                               , "WeightedAdjacencyMatrix"+                               , "WeightedGraphQ"+                               , "Weights"+                               , "WheelGraph"+                               , "Which"+                               , "While"+                               , "White"+                               , "Whitespace"+                               , "WhitespaceCharacter"+                               , "WhittakerM"+                               , "WhittakerW"+                               , "WienerFilter"+                               , "WignerD"+                               , "WignerSemicircleDistribution"+                               , "WindowClickSelect"+                               , "WindowElements"+                               , "WindowFloating"+                               , "WindowFrame"+                               , "WindowMargins"+                               , "WindowMovable"+                               , "WindowOpacity"+                               , "WindowSize"+                               , "WindowStatusArea"+                               , "WindowTitle"+                               , "WindowToolbars"+                               , "With"+                               , "WolframAlpha"+                               , "Word"+                               , "WordBoundary"+                               , "WordCharacter"+                               , "WordData"+                               , "WordSearch"+                               , "WordSeparators"+                               , "WorkingPrecision"+                               , "Write"+                               , "WriteString"+                               , "Wronskian"+                               , "X"+                               , "XMLElement"+                               , "XMLObject"+                               , "Xnor"+                               , "Xor"+                               , "Y"+                               , "Yellow"+                               , "YuleDissimilarity"+                               , "Z"+                               , "ZernikeR"+                               , "ZeroTest"+                               , "Zeta"+                               , "ZetaZero"+                               , "ZipfDistribution"+                               , "ZTest"+                               , "ZTransform"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z_0-9]+\\_"+                              , reCompiled = Just (compileRegex True "[a-zA-Z_0-9]+\\_")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\-\\>|\\/\\.)"+                              , reCompiled = Just (compileRegex True "(\\-\\>|\\/\\.)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "+*/%\\|-^"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(:=|=)"+                              , reCompiled = Just (compileRegex True "(:=|=)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Sven Brauch (svenbrauch@gmail.com)"+  , sVersion = "9"+  , sLicense = "LGPL"+  , sExtensions = [ "*.nb" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Matlab.hs view
@@ -0,0 +1,457 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Matlab (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Matlab"+  , sFilename = "matlab.xml"+  , sShortname = "Matlab"+  , sContexts =+      fromList+        [ ( "_adjoint"+          , Context+              { cName = "_adjoint"+              , cSyntax = "Matlab"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'+"+                              , reCompiled = Just (compileRegex True "'+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "_normal"+          , Context+              { cName = "_normal"+              , cSyntax = "Matlab"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z]\\w*(?=')"+                              , reCompiled = Just (compileRegex True "[a-zA-Z]\\w*(?=')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Matlab" , "_adjoint" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\d+(\\.\\d+)?|\\.\\d+)([eE][+-]?\\d+)?[ij]?(?=')"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(\\d+(\\.\\d+)?|\\.\\d+)([eE][+-]?\\d+)?[ij]?(?=')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Matlab" , "_adjoint" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\)\\]}](?=')"+                              , reCompiled = Just (compileRegex True "[\\)\\]}](?=')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Matlab" , "_adjoint" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.'(?=')"+                              , reCompiled = Just (compileRegex True "\\.'(?=')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Matlab" , "_adjoint" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'[^']*(''[^']*)*'(?=[^']|$)"+                              , reCompiled =+                                  Just (compileRegex True "'[^']*(''[^']*)*'(?=[^']|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'[^']*(''[^']*)*"+                              , reCompiled = Just (compileRegex True "'[^']*(''[^']*)*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "break"+                               , "case"+                               , "catch"+                               , "classdef"+                               , "continue"+                               , "else"+                               , "elseif"+                               , "end"+                               , "events"+                               , "for"+                               , "function"+                               , "global"+                               , "if"+                               , "methods"+                               , "otherwise"+                               , "parfor"+                               , "persistent"+                               , "properties"+                               , "return"+                               , "spmd"+                               , "switch"+                               , "try"+                               , "while"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%.*$"+                              , reCompiled = Just (compileRegex True "%.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "!.*$"+                              , reCompiled = Just (compileRegex True "!.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z]\\w*"+                              , reCompiled = Just (compileRegex True "[a-zA-Z]\\w*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\d+(\\.\\d+)?|\\.\\d+)([eE][+-]?\\d+)?[ij]?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(\\d+(\\.\\d+)?|\\.\\d+)([eE][+-]?\\d+)?[ij]?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "()[]{}"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "..."+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "=="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "~="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect ">="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "&&"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "||"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect ".*"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect ".^"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "./"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect ".'"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "*+-/\\&|<>~^=,;:@"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = ""+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.m" , "*.M" ]+  , sStartingContext = "_normal"+  }
+ src/Skylighting/Syntax/Maxima.hs view
@@ -0,0 +1,2113 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Maxima (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Maxima"+  , sFilename = "maxima.xml"+  , sShortname = "Maxima"+  , sContexts =+      fromList+        [ ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "Maxima"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !#&()*+,-./:;<=>?@[\\]^{|}~"+                              }+                            (makeWordSet True [ "FIXME" , "TODO" ])+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal Text"+          , Context+              { cName = "Normal Text"+              , cSyntax = "Maxima"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !#&()*+,-./:;<=>?@[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "%th"+                               , "AntiDifference"+                               , "Gosper"+                               , "GosperSum"+                               , "JF"+                               , "Lindstedt"+                               , "ModeMatrix"+                               , "Zeilberger"+                               , "abasep"+                               , "abs"+                               , "absint"+                               , "absolute_real_time"+                               , "acos"+                               , "acosh"+                               , "acot"+                               , "acoth"+                               , "acsc"+                               , "acsch"+                               , "activate"+                               , "add_edge"+                               , "add_edges"+                               , "add_vertex"+                               , "add_vertices"+                               , "addcol"+                               , "addmatrices"+                               , "addrow"+                               , "adjacency_matrix"+                               , "adjoin"+                               , "adjoint"+                               , "af"+                               , "agd"+                               , "airy_ai"+                               , "airy_bi"+                               , "airy_dai"+                               , "airy_dbi"+                               , "alg_type"+                               , "algsys"+                               , "alias"+                               , "allroots"+                               , "alphacharp"+                               , "alphanumericp"+                               , "antid"+                               , "antidiff"+                               , "append"+                               , "appendfile"+                               , "apply"+                               , "apply1"+                               , "apply2"+                               , "applyb1"+                               , "apropos"+                               , "args"+                               , "arithmetic"+                               , "arithsum"+                               , "array"+                               , "arrayapply"+                               , "arrayinfo"+                               , "arraymake"+                               , "ascii"+                               , "asec"+                               , "asech"+                               , "asin"+                               , "asinh"+                               , "askinteger"+                               , "asksign"+                               , "assoc"+                               , "assoc_legendre_p"+                               , "assoc_legendre_q"+                               , "assume"+                               , "asympa"+                               , "at"+                               , "atan"+                               , "atan2"+                               , "atanh"+                               , "atensimp"+                               , "atom"+                               , "atvalue"+                               , "augcoefmatrix"+                               , "augmented_lagrangian_method"+                               , "av"+                               , "average_degree"+                               , "backtrace"+                               , "barsplot"+                               , "bashindices"+                               , "batch"+                               , "batchload"+                               , "bc2"+                               , "bdvac"+                               , "belln"+                               , "bern"+                               , "bernpoly"+                               , "bessel"+                               , "bessel_i"+                               , "bessel_j"+                               , "bessel_k"+                               , "bessel_y"+                               , "beta"+                               , "bezout"+                               , "bffac"+                               , "bfhzeta"+                               , "bfloat"+                               , "bfloatp"+                               , "bfpsi"+                               , "bfpsi0"+                               , "bfzeta"+                               , "biconected_components"+                               , "bimetric"+                               , "binomial"+                               , "bipartition"+                               , "block"+                               , "blockmatrixp"+                               , "bode_gain"+                               , "bode_phase"+                               , "bothcoef"+                               , "box"+                               , "boxplot"+                               , "break"+                               , "bug_report"+                               , "build_info"+                               , "buildq"+                               , "burn"+                               , "cabs"+                               , "canform"+                               , "canten"+                               , "cardinality"+                               , "carg"+                               , "cartan"+                               , "cartesian_product"+                               , "catch"+                               , "cbffac"+                               , "cdf_bernoulli"+                               , "cdf_beta"+                               , "cdf_binomial"+                               , "cdf_cauchy"+                               , "cdf_chi2"+                               , "cdf_continuous_uniform"+                               , "cdf_discrete_uniform"+                               , "cdf_exp"+                               , "cdf_f"+                               , "cdf_gamma"+                               , "cdf_geometric"+                               , "cdf_gumbel"+                               , "cdf_hypergeometric"+                               , "cdf_laplace"+                               , "cdf_logistic"+                               , "cdf_lognormal"+                               , "cdf_negative_binomial"+                               , "cdf_normal"+                               , "cdf_pareto"+                               , "cdf_poisson"+                               , "cdf_rank_sum"+                               , "cdf_rayleigh"+                               , "cdf_signed_rank"+                               , "cdf_student_t"+                               , "cdf_weibull"+                               , "cdisplay"+                               , "ceiling"+                               , "central_moment"+                               , "cequal"+                               , "cequalignore"+                               , "cf"+                               , "cfdisrep"+                               , "cfexpand"+                               , "cgeodesic"+                               , "cgreaterp"+                               , "cgreaterpignore"+                               , "changename"+                               , "changevar"+                               , "chaosgame"+                               , "charat"+                               , "charfun"+                               , "charfun2"+                               , "charlist"+                               , "charp"+                               , "charpoly"+                               , "chebyshev_t"+                               , "chebyshev_u"+                               , "check_overlaps"+                               , "checkdiv"+                               , "cholesky"+                               , "christof"+                               , "chromatic_index"+                               , "chromatic_number"+                               , "cint"+                               , "circulant_graph"+                               , "clear_edge_weight"+                               , "clear_rules"+                               , "clear_vertex_label"+                               , "clebsch_graph"+                               , "clessp"+                               , "clesspignore"+                               , "close"+                               , "closefile"+                               , "cmetric"+                               , "coeff"+                               , "coefmatrix"+                               , "cograd"+                               , "col"+                               , "collapse"+                               , "collectterms"+                               , "columnop"+                               , "columnspace"+                               , "columnswap"+                               , "columnvector"+                               , "combination"+                               , "combine"+                               , "comp2pui"+                               , "compare"+                               , "compfile"+                               , "compile"+                               , "compile_file"+                               , "complement_graph"+                               , "complete_bipartite_graph"+                               , "complete_graph"+                               , "components"+                               , "concan"+                               , "concat"+                               , "conjugate"+                               , "conmetderiv"+                               , "connect_vertices"+                               , "connected_components"+                               , "cons"+                               , "constantp"+                               , "constituent"+                               , "cont2part"+                               , "content"+                               , "continuous_freq"+                               , "contortion"+                               , "contour_plot"+                               , "contract"+                               , "contract_edge"+                               , "contragrad"+                               , "contrib_ode"+                               , "convert"+                               , "coord"+                               , "copy"+                               , "copy_graph"+                               , "copylist"+                               , "copymatrix"+                               , "cor"+                               , "cos"+                               , "cosh"+                               , "cot"+                               , "coth"+                               , "cov"+                               , "cov1"+                               , "covdiff"+                               , "covect"+                               , "covers"+                               , "create_graph"+                               , "create_list"+                               , "csc"+                               , "csch"+                               , "csetup"+                               , "cspline"+                               , "ct_coordsys"+                               , "ctaylor"+                               , "ctransform"+                               , "ctranspose"+                               , "cube_graph"+                               , "cunlisp"+                               , "cv"+                               , "cycle_digraph"+                               , "cycle_graph"+                               , "dblint"+                               , "deactivate"+                               , "declare"+                               , "declare_translated"+                               , "declare_weight"+                               , "decsym"+                               , "defcon"+                               , "define"+                               , "define_variable"+                               , "defint"+                               , "defmatch"+                               , "defrule"+                               , "deftaylor"+                               , "degree_sequence"+                               , "del"+                               , "delete"+                               , "deleten"+                               , "delta"+                               , "demo"+                               , "demoivre"+                               , "denom"+                               , "depends"+                               , "derivdegree"+                               , "derivlist"+                               , "describe"+                               , "desolve"+                               , "determinant"+                               , "dgauss_a"+                               , "dgauss_b"+                               , "dgeev"+                               , "dgesvd"+                               , "diag"+                               , "diag_matrix"+                               , "diagmatrix"+                               , "diagmatrixp"+                               , "diameter"+                               , "diff"+                               , "digitcharp"+                               , "dimacs_export"+                               , "dimacs_import"+                               , "dimension"+                               , "direct"+                               , "discrete_freq"+                               , "disjoin"+                               , "disjointp"+                               , "disolate"+                               , "disp"+                               , "dispJordan"+                               , "dispcon"+                               , "dispform"+                               , "dispfun"+                               , "display"+                               , "disprule"+                               , "dispterms"+                               , "distrib"+                               , "divide"+                               , "divisors"+                               , "divsum"+                               , "dkummer_m"+                               , "dkummer_u"+                               , "dlange"+                               , "dodecahedron_graph"+                               , "dotproduct"+                               , "dotsimp"+                               , "dpart"+                               , "draw"+                               , "draw2d"+                               , "draw3d"+                               , "draw_graph"+                               , "dscalar"+                               , "echelon"+                               , "edge_coloring"+                               , "edges"+                               , "eigens_by_jacobi"+                               , "eigenvalues"+                               , "eigenvectors"+                               , "eighth"+                               , "einstein"+                               , "eivals"+                               , "eivects"+                               , "elapsed_real_time"+                               , "elapsed_run_time"+                               , "ele2comp"+                               , "ele2polynome"+                               , "ele2pui"+                               , "elem"+                               , "elementp"+                               , "eliminate"+                               , "elliptic_e"+                               , "elliptic_ec"+                               , "elliptic_eu"+                               , "elliptic_f"+                               , "elliptic_kc"+                               , "elliptic_pi"+                               , "ematrix"+                               , "empty_graph"+                               , "emptyp"+                               , "endcons"+                               , "entermatrix"+                               , "entertensor"+                               , "entier"+                               , "equal"+                               , "equalp"+                               , "equiv_classes"+                               , "erf"+                               , "errcatch"+                               , "error"+                               , "errormsg"+                               , "euler"+                               , "ev"+                               , "eval_string"+                               , "evenp"+                               , "every"+                               , "evolution"+                               , "evolution2d"+                               , "evundiff"+                               , "example"+                               , "exp"+                               , "expand"+                               , "expandwrt"+                               , "expandwrt_factored"+                               , "explose"+                               , "exponentialize"+                               , "express"+                               , "expt"+                               , "exsec"+                               , "extdiff"+                               , "extract_linear_equations"+                               , "extremal_subset"+                               , "ezgcd"+                               , "f90"+                               , "facsum"+                               , "factcomb"+                               , "factor"+                               , "factorfacsum"+                               , "factorial"+                               , "factorout"+                               , "factorsum"+                               , "facts"+                               , "fast_central_elements"+                               , "fast_linsolve"+                               , "fasttimes"+                               , "featurep"+                               , "fft"+                               , "fib"+                               , "fibtophi"+                               , "fifth"+                               , "file_search"+                               , "file_type"+                               , "filename_merge"+                               , "fillarray"+                               , "find_root"+                               , "findde"+                               , "first"+                               , "fix"+                               , "flatten"+                               , "flength"+                               , "float"+                               , "floatnump"+                               , "floor"+                               , "flower_snark"+                               , "flush"+                               , "flush1deriv"+                               , "flushd"+                               , "flushnd"+                               , "forget"+                               , "fortran"+                               , "fourcos"+                               , "fourexpand"+                               , "fourier"+                               , "fourint"+                               , "fourintcos"+                               , "fourintsin"+                               , "foursimp"+                               , "foursin"+                               , "fourth"+                               , "fposition"+                               , "frame_bracket"+                               , "freeof"+                               , "freshline"+                               , "from_adjacency_matrix"+                               , "frucht_graph"+                               , "full_listify"+                               , "fullmap"+                               , "fullmapl"+                               , "fullratsimp"+                               , "fullratsubst"+                               , "fullsetify"+                               , "funcsolve"+                               , "fundef"+                               , "funmake"+                               , "funp"+                               , "gamma"+                               , "gauss_a"+                               , "gauss_b"+                               , "gaussprob"+                               , "gcd"+                               , "gcdex"+                               , "gcdivide"+                               , "gcfac"+                               , "gcfactor"+                               , "gd"+                               , "gen_laguerre"+                               , "genfact"+                               , "genmatrix"+                               , "geometric"+                               , "geometric_mean"+                               , "geosum"+                               , "get"+                               , "get_edge_weight"+                               , "get_lu_factors"+                               , "get_pixel"+                               , "get_vertex_label"+                               , "gfactor"+                               , "gfactorsum"+                               , "ggf"+                               , "girth"+                               , "global_variances"+                               , "gnuplot_close"+                               , "gnuplot_replot"+                               , "gnuplot_reset"+                               , "gnuplot_restart"+                               , "gnuplot_start"+                               , "go"+                               , "gradef"+                               , "gramschmidt"+                               , "graph6_decode"+                               , "graph6_encode"+                               , "graph6_export"+                               , "graph6_import"+                               , "graph_center"+                               , "graph_charpoly"+                               , "graph_eigenvalues"+                               , "graph_order"+                               , "graph_periphery"+                               , "graph_product"+                               , "graph_size"+                               , "graph_union"+                               , "grid_graph"+                               , "grind"+                               , "grobner_basis"+                               , "grotzch_graph"+                               , "hamilton_cycle"+                               , "hamilton_path"+                               , "hankel"+                               , "harmonic"+                               , "harmonic_mean"+                               , "hav"+                               , "heawood_graph"+                               , "hermite"+                               , "hessian"+                               , "hilbert_matrix"+                               , "hipow"+                               , "histogram"+                               , "hodge"+                               , "horner"+                               , "ic1"+                               , "ic2"+                               , "ic_convert"+                               , "ichr1"+                               , "ichr2"+                               , "icosahedron_graph"+                               , "icurvature"+                               , "ident"+                               , "identfor"+                               , "identity"+                               , "idiff"+                               , "idim"+                               , "idummy"+                               , "ieqn"+                               , "ifactors"+                               , "iframes"+                               , "ifs"+                               , "ift"+                               , "igeodesic_coords"+                               , "ilt"+                               , "imagpart"+                               , "imetric"+                               , "implicit_derivative"+                               , "implicit_plot"+                               , "in_neighbors"+                               , "indexed_tensor"+                               , "indices"+                               , "induced_subgraph"+                               , "inference_result"+                               , "inferencep"+                               , "infix"+                               , "init_atensor"+                               , "init_ctensor"+                               , "innerproduct"+                               , "inpart"+                               , "inprod"+                               , "inrt"+                               , "integer_partitions"+                               , "integerp"+                               , "integrate"+                               , "intersect"+                               , "intersection"+                               , "intervalp"+                               , "intopois"+                               , "intosum"+                               , "inv_mod"+                               , "invariant1"+                               , "invariant2"+                               , "inverse_jacobi_cd"+                               , "inverse_jacobi_cn"+                               , "inverse_jacobi_cs"+                               , "inverse_jacobi_dc"+                               , "inverse_jacobi_dn"+                               , "inverse_jacobi_ds"+                               , "inverse_jacobi_nc"+                               , "inverse_jacobi_nd"+                               , "inverse_jacobi_ns"+                               , "inverse_jacobi_sc"+                               , "inverse_jacobi_sd"+                               , "inverse_jacobi_sn"+                               , "invert"+                               , "invert_by_lu"+                               , "is"+                               , "is_biconnected"+                               , "is_bipartite"+                               , "is_connected"+                               , "is_digraph"+                               , "is_edge_in_graph"+                               , "is_graph"+                               , "is_graph_or_digraph"+                               , "is_isomorphic"+                               , "is_planar"+                               , "is_sconnected"+                               , "is_tree"+                               , "is_vertex_in_graph"+                               , "ishow"+                               , "isolate"+                               , "isomorphism"+                               , "isqrt"+                               , "items_inference"+                               , "jacobi"+                               , "jacobi_cd"+                               , "jacobi_cn"+                               , "jacobi_cs"+                               , "jacobi_dc"+                               , "jacobi_dn"+                               , "jacobi_ds"+                               , "jacobi_nc"+                               , "jacobi_nd"+                               , "jacobi_ns"+                               , "jacobi_p"+                               , "jacobi_sc"+                               , "jacobi_sd"+                               , "jacobi_sn"+                               , "jacobian"+                               , "join"+                               , "jordan"+                               , "julia"+                               , "kdels"+                               , "kdelta"+                               , "kill"+                               , "killcontext"+                               , "kostka"+                               , "kron_delta"+                               , "kronecker_product"+                               , "kummer_m"+                               , "kummer_u"+                               , "kurtosis"+                               , "kurtosis_bernoulli"+                               , "kurtosis_beta"+                               , "kurtosis_binomial"+                               , "kurtosis_chi2"+                               , "kurtosis_continuous_uniform"+                               , "kurtosis_discrete_uniform"+                               , "kurtosis_exp"+                               , "kurtosis_f"+                               , "kurtosis_gamma"+                               , "kurtosis_geometric"+                               , "kurtosis_gumbel"+                               , "kurtosis_hypergeometric"+                               , "kurtosis_laplace"+                               , "kurtosis_logistic"+                               , "kurtosis_lognormal"+                               , "kurtosis_negative_binomial"+                               , "kurtosis_normal"+                               , "kurtosis_pareto"+                               , "kurtosis_poisson"+                               , "kurtosis_rayleigh"+                               , "kurtosis_student_t"+                               , "kurtosis_weibull"+                               , "labels"+                               , "lagrange"+                               , "laguerre"+                               , "lambda"+                               , "laplace"+                               , "laplacian_matrix"+                               , "last"+                               , "lbfgs"+                               , "lc2kdt"+                               , "lc_l"+                               , "lc_u"+                               , "lcharp"+                               , "lcm"+                               , "ldefint"+                               , "ldisp"+                               , "ldisplay"+                               , "legendre_p"+                               , "legendre_q"+                               , "leinstein"+                               , "length"+                               , "let"+                               , "letrules"+                               , "letsimp"+                               , "levi_civita"+                               , "lfreeof"+                               , "lgtreillis"+                               , "lhs"+                               , "li"+                               , "liediff"+                               , "limit"+                               , "line_graph"+                               , "linear"+                               , "linear_program"+                               , "linearinterpol"+                               , "linsolve"+                               , "list_correlations"+                               , "list_nc_monomials"+                               , "listarray"+                               , "listify"+                               , "listoftens"+                               , "listofvars"+                               , "listp"+                               , "lmax"+                               , "lmin"+                               , "load"+                               , "loadfile"+                               , "local"+                               , "locate_matrix_entry"+                               , "log"+                               , "logand"+                               , "logarc"+                               , "logcontract"+                               , "logor"+                               , "logxor"+                               , "lopow"+                               , "lorentz_gauge"+                               , "lowercasep"+                               , "lpart"+                               , "lratsubst"+                               , "lreduce"+                               , "lriemann"+                               , "lsquares_estimates"+                               , "lsquares_estimates_approximate"+                               , "lsquares_estimates_exact"+                               , "lsquares_mse"+                               , "lsquares_residual_mse"+                               , "lsquares_residuals"+                               , "lsum"+                               , "ltreillis"+                               , "lu_backsub"+                               , "lu_factor"+                               , "macroexpand"+                               , "macroexpand1"+                               , "makeOrders"+                               , "make_array"+                               , "make_level_picture"+                               , "make_poly_continent"+                               , "make_poly_country"+                               , "make_polygon"+                               , "make_random_state"+                               , "make_rgb_picture"+                               , "make_transform"+                               , "makebox"+                               , "makefact"+                               , "makegamma"+                               , "makelist"+                               , "makeset"+                               , "mandelbrot"+                               , "map"+                               , "mapatom"+                               , "maplist"+                               , "mat_cond"+                               , "mat_fullunblocker"+                               , "mat_function"+                               , "mat_norm"+                               , "mat_trace"+                               , "mat_unblocker"+                               , "matchdeclare"+                               , "matchfix"+                               , "matrix"+                               , "matrix_size"+                               , "matrixmap"+                               , "matrixp"+                               , "mattrace"+                               , "max"+                               , "max_clique"+                               , "max_degree"+                               , "max_flow"+                               , "max_independent_set"+                               , "max_matching"+                               , "maxi"+                               , "maximize_lp"+                               , "maybe"+                               , "mean"+                               , "mean_bernoulli"+                               , "mean_beta"+                               , "mean_binomial"+                               , "mean_chi2"+                               , "mean_continuous_uniform"+                               , "mean_deviation"+                               , "mean_discrete_uniform"+                               , "mean_exp"+                               , "mean_f"+                               , "mean_gamma"+                               , "mean_geometric"+                               , "mean_gumbel"+                               , "mean_hypergeometric"+                               , "mean_laplace"+                               , "mean_logistic"+                               , "mean_lognormal"+                               , "mean_negative_binomial"+                               , "mean_normal"+                               , "mean_pareto"+                               , "mean_poisson"+                               , "mean_rayleigh"+                               , "mean_student_t"+                               , "mean_weibull"+                               , "median"+                               , "median_deviation"+                               , "member"+                               , "metricexpandall"+                               , "min"+                               , "min_degree"+                               , "minfactorial"+                               , "mini"+                               , "minimalPoly"+                               , "minimize_lp"+                               , "minimum_spanning_tree"+                               , "minor"+                               , "mnewton"+                               , "mod"+                               , "mode_declare"+                               , "mode_identity"+                               , "moebius"+                               , "mon2schur"+                               , "mono"+                               , "monomial_dimensions"+                               , "multi_elem"+                               , "multi_orbit"+                               , "multi_pui"+                               , "multinomial"+                               , "multinomial_coeff"+                               , "multsym"+                               , "multthru"+                               , "mycielski_graph"+                               , "nary"+                               , "nc_degree"+                               , "ncexpt"+                               , "ncharpoly"+                               , "negative_picture"+                               , "neighbors"+                               , "new_graph"+                               , "newcontext"+                               , "newdet"+                               , "newline"+                               , "newton"+                               , "next_prime"+                               , "niceindices"+                               , "ninth"+                               , "noncentral_moment"+                               , "nonmetricity"+                               , "nonnegintegerp"+                               , "nonscalarp"+                               , "nonzeroandfreeof"+                               , "notequal"+                               , "nounify"+                               , "nptetrad"+                               , "nroots"+                               , "nterms"+                               , "ntermst"+                               , "nthroot"+                               , "nullity"+                               , "nullspace"+                               , "num"+                               , "num_distinct_partitions"+                               , "num_partitions"+                               , "numbered_boundaries"+                               , "numberp"+                               , "numerval"+                               , "numfactor"+                               , "nusum"+                               , "odd_girth"+                               , "oddp"+                               , "ode2"+                               , "ode_check"+                               , "odelin"+                               , "op"+                               , "opena"+                               , "openr"+                               , "openw"+                               , "operatorp"+                               , "opsubst"+                               , "optimize"+                               , "orbit"+                               , "orbits"+                               , "ordergreat"+                               , "ordergreatp"+                               , "orderless"+                               , "orderlessp"+                               , "orthogonal_complement"+                               , "orthopoly_recur"+                               , "orthopoly_weight"+                               , "out_neighbors"+                               , "outermap"+                               , "outofpois"+                               , "pade"+                               , "parGosper"+                               , "parse_string"+                               , "part"+                               , "part2cont"+                               , "partfrac"+                               , "partition"+                               , "partition_set"+                               , "partpol"+                               , "path_digraph"+                               , "path_graph"+                               , "pdf_bernoulli"+                               , "pdf_beta"+                               , "pdf_binomial"+                               , "pdf_cauchy"+                               , "pdf_chi2"+                               , "pdf_continuous_uniform"+                               , "pdf_discrete_uniform"+                               , "pdf_exp"+                               , "pdf_f"+                               , "pdf_gamma"+                               , "pdf_geometric"+                               , "pdf_gumbel"+                               , "pdf_hypergeometric"+                               , "pdf_laplace"+                               , "pdf_logistic"+                               , "pdf_lognormal"+                               , "pdf_negative_binomial"+                               , "pdf_normal"+                               , "pdf_pareto"+                               , "pdf_poisson"+                               , "pdf_rank_sum"+                               , "pdf_rayleigh"+                               , "pdf_signed_rank"+                               , "pdf_student_t"+                               , "pdf_weibull"+                               , "pearson_skewness"+                               , "permanent"+                               , "permut"+                               , "permutation"+                               , "permutations"+                               , "petersen_graph"+                               , "petrov"+                               , "pickapart"+                               , "picture_equalp"+                               , "picturep"+                               , "piechart"+                               , "planar_embedding"+                               , "playback"+                               , "plog"+                               , "plot2d"+                               , "plot3d"+                               , "plotdf"+                               , "plsquares"+                               , "pochhammer"+                               , "poisdiff"+                               , "poisexpt"+                               , "poisint"+                               , "poismap"+                               , "poisplus"+                               , "poissimp"+                               , "poissubst"+                               , "poistimes"+                               , "poistrim"+                               , "polarform"+                               , "polartorect"+                               , "poly_add"+                               , "poly_buchberger"+                               , "poly_buchberger_criterion"+                               , "poly_colon_ideal"+                               , "poly_content"+                               , "poly_depends_p"+                               , "poly_elimination_ideal"+                               , "poly_exact_divide"+                               , "poly_expand"+                               , "poly_expt"+                               , "poly_gcd"+                               , "poly_grobner"+                               , "poly_grobner_equal"+                               , "poly_grobner_member"+                               , "poly_grobner_subsetp"+                               , "poly_ideal_intersection"+                               , "poly_ideal_polysaturation"+                               , "poly_ideal_polysaturation1"+                               , "poly_ideal_saturation"+                               , "poly_ideal_saturation1"+                               , "poly_lcm"+                               , "poly_minimization"+                               , "poly_multiply"+                               , "poly_normal_form"+                               , "poly_normalize"+                               , "poly_normalize_list"+                               , "poly_polysaturation_extension"+                               , "poly_primitive_part"+                               , "poly_pseudo_divide"+                               , "poly_reduced_grobner"+                               , "poly_reduction"+                               , "poly_s_polynomial"+                               , "poly_saturation_extension"+                               , "poly_subtract"+                               , "polydecomp"+                               , "polymod"+                               , "polynome2ele"+                               , "polynomialp"+                               , "polytocompanion"+                               , "potential"+                               , "power_mod"+                               , "powers"+                               , "powerseries"+                               , "powerset"+                               , "prev_prime"+                               , "primep"+                               , "print"+                               , "print_graph"+                               , "printf"+                               , "printpois"+                               , "printprops"+                               , "prodrac"+                               , "product"+                               , "properties"+                               , "propvars"+                               , "psi"+                               , "ptriangularize"+                               , "pui"+                               , "pui2comp"+                               , "pui2ele"+                               , "pui2polynome"+                               , "pui_direct"+                               , "puireduc"+                               , "put"+                               , "qput"+                               , "qrange"+                               , "quad_qag"+                               , "quad_qagi"+                               , "quad_qags"+                               , "quad_qawc"+                               , "quad_qawf"+                               , "quad_qawo"+                               , "quad_qaws"+                               , "quantile"+                               , "quantile_bernoulli"+                               , "quantile_beta"+                               , "quantile_binomial"+                               , "quantile_cauchy"+                               , "quantile_chi2"+                               , "quantile_continuous_uniform"+                               , "quantile_discrete_uniform"+                               , "quantile_exp"+                               , "quantile_f"+                               , "quantile_gamma"+                               , "quantile_geometric"+                               , "quantile_gumbel"+                               , "quantile_hypergeometric"+                               , "quantile_laplace"+                               , "quantile_logistic"+                               , "quantile_lognormal"+                               , "quantile_negative_binomial"+                               , "quantile_normal"+                               , "quantile_pareto"+                               , "quantile_poisson"+                               , "quantile_rayleigh"+                               , "quantile_student_t"+                               , "quantile_weibull"+                               , "quartile_skewness"+                               , "quit"+                               , "qunit"+                               , "quotient"+                               , "radcan"+                               , "radius"+                               , "random"+                               , "random_bernoulli"+                               , "random_beta"+                               , "random_binomial"+                               , "random_cauchy"+                               , "random_chi2"+                               , "random_continuous_uniform"+                               , "random_digraph"+                               , "random_discrete_uniform"+                               , "random_exp"+                               , "random_f"+                               , "random_gamma"+                               , "random_geometric"+                               , "random_graph"+                               , "random_graph1"+                               , "random_gumbel"+                               , "random_hypergeometric"+                               , "random_laplace"+                               , "random_logistic"+                               , "random_lognormal"+                               , "random_negative_binomial"+                               , "random_network"+                               , "random_normal"+                               , "random_pareto"+                               , "random_permutation"+                               , "random_poisson"+                               , "random_rayleigh"+                               , "random_regular_graph"+                               , "random_student_t"+                               , "random_tournament"+                               , "random_tree"+                               , "random_weibull"+                               , "range"+                               , "rank"+                               , "rat"+                               , "ratcoef"+                               , "ratdenom"+                               , "ratdiff"+                               , "ratdisrep"+                               , "ratexpand"+                               , "rational"+                               , "rationalize"+                               , "ratnumer"+                               , "ratnump"+                               , "ratp"+                               , "ratsimp"+                               , "ratsubst"+                               , "ratvars"+                               , "ratweight"+                               , "read"+                               , "read_hashed_array"+                               , "read_lisp_array"+                               , "read_list"+                               , "read_matrix"+                               , "read_maxima_array"+                               , "read_nested_list"+                               , "read_xpm"+                               , "readline"+                               , "readonly"+                               , "realpart"+                               , "realroots"+                               , "rearray"+                               , "rectform"+                               , "recttopolar"+                               , "rediff"+                               , "reduce_consts"+                               , "reduce_order"+                               , "region_boundaries"+                               , "rem"+                               , "remainder"+                               , "remarray"+                               , "rembox"+                               , "remcomps"+                               , "remcon"+                               , "remcoord"+                               , "remfun"+                               , "remfunction"+                               , "remlet"+                               , "remove"+                               , "remove_edge"+                               , "remove_vertex"+                               , "rempart"+                               , "remrule"+                               , "remsym"+                               , "remvalue"+                               , "rename"+                               , "reset"+                               , "residue"+                               , "resolvante"+                               , "resolvante_alternee1"+                               , "resolvante_bipartite"+                               , "resolvante_diedrale"+                               , "resolvante_klein"+                               , "resolvante_klein3"+                               , "resolvante_produit_sym"+                               , "resolvante_unitaire"+                               , "resolvante_vierer"+                               , "rest"+                               , "resultant"+                               , "return"+                               , "reveal"+                               , "reverse"+                               , "revert"+                               , "revert2"+                               , "rgb2level"+                               , "rhs"+                               , "ricci"+                               , "riemann"+                               , "rinvariant"+                               , "risch"+                               , "rk"+                               , "rncombine"+                               , "romberg"+                               , "room"+                               , "rootscontract"+                               , "row"+                               , "rowop"+                               , "rowswap"+                               , "rreduce"+                               , "run_testsuite"+                               , "save"+                               , "scalarp"+                               , "scaled_bessel_i"+                               , "scaled_bessel_i0"+                               , "scaled_bessel_i1"+                               , "scalefactors"+                               , "scanmap"+                               , "scatterplot"+                               , "schur2comp"+                               , "sconcat"+                               , "scopy"+                               , "scsimp"+                               , "scurvature"+                               , "sdowncase"+                               , "sec"+                               , "sech"+                               , "second"+                               , "sequal"+                               , "sequalignore"+                               , "set_edge_weight"+                               , "set_partitions"+                               , "set_plot_option"+                               , "set_random_state"+                               , "set_up_dot_simplifications"+                               , "set_vertex_label"+                               , "setdifference"+                               , "setelmx"+                               , "setequalp"+                               , "setify"+                               , "setp"+                               , "setunits"+                               , "setup_autoload"+                               , "seventh"+                               , "sexplode"+                               , "sf"+                               , "shortest_path"+                               , "show"+                               , "showcomps"+                               , "showratvars"+                               , "sign"+                               , "signum"+                               , "similaritytransform"+                               , "simple_linear_regression"+                               , "simplify_sum"+                               , "simplode"+                               , "simpmetderiv"+                               , "simtran"+                               , "sin"+                               , "sinh"+                               , "sinsert"+                               , "sinvertcase"+                               , "sixth"+                               , "skewness"+                               , "skewness_bernoulli"+                               , "skewness_beta"+                               , "skewness_binomial"+                               , "skewness_chi2"+                               , "skewness_continuous_uniform"+                               , "skewness_discrete_uniform"+                               , "skewness_exp"+                               , "skewness_f"+                               , "skewness_gamma"+                               , "skewness_geometric"+                               , "skewness_gumbel"+                               , "skewness_hypergeometric"+                               , "skewness_laplace"+                               , "skewness_logistic"+                               , "skewness_lognormal"+                               , "skewness_negative_binomial"+                               , "skewness_normal"+                               , "skewness_pareto"+                               , "skewness_poisson"+                               , "skewness_rayleigh"+                               , "skewness_student_t"+                               , "skewness_weibull"+                               , "slength"+                               , "smake"+                               , "smismatch"+                               , "solve"+                               , "solve_rec"+                               , "solve_rec_rat"+                               , "some"+                               , "somrac"+                               , "sort"+                               , "sparse6_decode"+                               , "sparse6_encode"+                               , "sparse6_export"+                               , "sparse6_import"+                               , "specint"+                               , "spherical_bessel_j"+                               , "spherical_bessel_y"+                               , "spherical_hankel1"+                               , "spherical_hankel2"+                               , "spherical_harmonic"+                               , "splice"+                               , "split"+                               , "sposition"+                               , "sprint"+                               , "sqfr"+                               , "sqrt"+                               , "sqrtdenest"+                               , "sremove"+                               , "sremovefirst"+                               , "sreverse"+                               , "ssearch"+                               , "ssort"+                               , "sstatus"+                               , "ssubst"+                               , "ssubstfirst"+                               , "staircase"+                               , "status"+                               , "std"+                               , "std1"+                               , "std_bernoulli"+                               , "std_beta"+                               , "std_binomial"+                               , "std_chi2"+                               , "std_continuous_uniform"+                               , "std_discrete_uniform"+                               , "std_exp"+                               , "std_f"+                               , "std_gamma"+                               , "std_geometric"+                               , "std_gumbel"+                               , "std_hypergeometric"+                               , "std_laplace"+                               , "std_logistic"+                               , "std_lognormal"+                               , "std_negative_binomial"+                               , "std_normal"+                               , "std_pareto"+                               , "std_poisson"+                               , "std_rayleigh"+                               , "std_student_t"+                               , "std_weibull"+                               , "stirling"+                               , "stirling1"+                               , "stirling2"+                               , "strim"+                               , "striml"+                               , "strimr"+                               , "string"+                               , "stringout"+                               , "stringp"+                               , "strong_components"+                               , "sublis"+                               , "sublist"+                               , "sublist_indices"+                               , "submatrix"+                               , "subsample"+                               , "subset"+                               , "subsetp"+                               , "subst"+                               , "substinpart"+                               , "substpart"+                               , "substring"+                               , "subvar"+                               , "subvarp"+                               , "sum"+                               , "sumcontract"+                               , "summand_to_rec"+                               , "supcase"+                               , "supcontext"+                               , "symbolp"+                               , "symmdifference"+                               , "symmetricp"+                               , "system"+                               , "take_channel"+                               , "take_inference"+                               , "tan"+                               , "tanh"+                               , "taylor"+                               , "taylor_simplifier"+                               , "taylorinfo"+                               , "taylorp"+                               , "taytorat"+                               , "tcl_output"+                               , "tcontract"+                               , "tellrat"+                               , "tellsimp"+                               , "tellsimpafter"+                               , "tentex"+                               , "tenth"+                               , "test_mean"+                               , "test_means_difference"+                               , "test_normality"+                               , "test_rank_sum"+                               , "test_sign"+                               , "test_signed_rank"+                               , "test_variance"+                               , "test_variance_ratio"+                               , "tex"+                               , "texput"+                               , "third"+                               , "throw"+                               , "time"+                               , "timedate"+                               , "timer"+                               , "timer_info"+                               , "tldefint"+                               , "tlimit"+                               , "to_lisp"+                               , "todd_coxeter"+                               , "toeplitz"+                               , "tokens"+                               , "topological_sort"+                               , "totaldisrep"+                               , "totalfourier"+                               , "totient"+                               , "tpartpol"+                               , "tr_warnings_get"+                               , "trace"+                               , "trace_options"+                               , "tracematrix"+                               , "translate"+                               , "translate_file"+                               , "transpose"+                               , "tree_reduce"+                               , "treillis"+                               , "treinat"+                               , "triangularize"+                               , "trigexpand"+                               , "trigrat"+                               , "trigreduce"+                               , "trigsimp"+                               , "trunc"+                               , "ueivects"+                               , "uforget"+                               , "ultraspherical"+                               , "underlying_graph"+                               , "undiff"+                               , "union"+                               , "unique"+                               , "unit_step"+                               , "uniteigenvectors"+                               , "unitvector"+                               , "unknown"+                               , "unorder"+                               , "unsum"+                               , "untellrat"+                               , "untimer"+                               , "untrace"+                               , "uppercasep"+                               , "uricci"+                               , "uriemann"+                               , "uvect"+                               , "vandermonde_matrix"+                               , "var"+                               , "var1"+                               , "var_bernoulli"+                               , "var_beta"+                               , "var_binomial"+                               , "var_chi2"+                               , "var_continuous_uniform"+                               , "var_discrete_uniform"+                               , "var_exp"+                               , "var_f"+                               , "var_gamma"+                               , "var_geometric"+                               , "var_gumbel"+                               , "var_hypergeometric"+                               , "var_laplace"+                               , "var_logistic"+                               , "var_lognormal"+                               , "var_negative_binomial"+                               , "var_normal"+                               , "var_pareto"+                               , "var_poisson"+                               , "var_rayleigh"+                               , "var_student_t"+                               , "var_weibull"+                               , "vectorpotential"+                               , "vectorsimp"+                               , "verbify"+                               , "vers"+                               , "vertex_coloring"+                               , "vertex_degree"+                               , "vertex_distance"+                               , "vertex_eccentricity"+                               , "vertex_in_degree"+                               , "vertex_out_degree"+                               , "vertices"+                               , "vertices_to_cycle"+                               , "vertices_to_path"+                               , "weyl"+                               , "wheel_graph"+                               , "with_stdout"+                               , "write_data"+                               , "writefile"+                               , "wronskian"+                               , "xgraph_curves"+                               , "xreduce"+                               , "xthru"+                               , "zeroequiv"+                               , "zerofor"+                               , "zeromatrix"+                               , "zeromatrixp"+                               , "zeta"+                               , "zlange"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !#&()*+,-./:;<=>?@[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "%"+                               , "%%"+                               , "%e_to_numlog"+                               , "%edispflag"+                               , "%emode"+                               , "%enumer"+                               , "%iargs"+                               , "%piargs"+                               , "%rnum_list"+                               , "GGFCFMAX"+                               , "GGFINFINITY"+                               , "_"+                               , "__"+                               , "absboxchar"+                               , "activecontexts"+                               , "additive"+                               , "algebraic"+                               , "algepsilon"+                               , "algexact"+                               , "aliases"+                               , "all_dotsimp_denoms"+                               , "allbut"+                               , "allsym"+                               , "arrays"+                               , "askexp"+                               , "assume_pos"+                               , "assume_pos_pred"+                               , "assumescalar"+                               , "atomgrad"+                               , "backsubst"+                               , "berlefact"+                               , "besselexpand"+                               , "bftorat"+                               , "bftrunc"+                               , "boxchar"+                               , "breakup"+                               , "cauchysum"+                               , "cflength"+                               , "cframe_flag"+                               , "cnonmet_flag"+                               , "context"+                               , "contexts"+                               , "cosnpiflag"+                               , "ct_coords"+                               , "ctaypov"+                               , "ctaypt"+                               , "ctayswitch"+                               , "ctayvar"+                               , "ctorsion_flag"+                               , "ctrgsimp"+                               , "current_let_rule_package"+                               , "debugmode"+                               , "default_let_rule_package"+                               , "demoivre"+                               , "dependencies"+                               , "derivabbrev"+                               , "derivsubst"+                               , "detout"+                               , "diagmetric"+                               , "dim"+                               , "dispflag"+                               , "display2d"+                               , "display_format_internal"+                               , "doallmxops"+                               , "domain"+                               , "domxexpt"+                               , "domxmxops"+                               , "domxnctimes"+                               , "dontfactor"+                               , "doscmxops"+                               , "doscmxplus"+                               , "dot0nscsimp"+                               , "dot0simp"+                               , "dot1simp"+                               , "dotassoc"+                               , "dotconstrules"+                               , "dotdistrib"+                               , "dotexptsimp"+                               , "dotident"+                               , "dotscrules"+                               , "draw_graph_program"+                               , "epsilon_lp"+                               , "erfflag"+                               , "error"+                               , "error_size"+                               , "error_syms"+                               , "evflag"+                               , "evfun"+                               , "expandwrt_denom"+                               , "expon"+                               , "exponentialize"+                               , "expop"+                               , "exptdispflag"+                               , "exptisolate"+                               , "exptsubst"+                               , "facexpand"+                               , "factlim"+                               , "factorflag"+                               , "file_output_append"+                               , "file_search_demo"+                               , "file_search_lisp"+                               , "file_search_maxima"+                               , "find_root_abs"+                               , "find_root_error"+                               , "find_root_rel"+                               , "flipflag"+                               , "float2bf"+                               , "fortindent"+                               , "fortspaces"+                               , "fpprec"+                               , "fpprintprec"+                               , "functions"+                               , "gammalim"+                               , "gdet"+                               , "genindex"+                               , "gensumnum"+                               , "globalsolve"+                               , "gradefs"+                               , "grind"+                               , "halfangles"+                               , "ibase"+                               , "icounter"+                               , "idummyx"+                               , "ieqnprint"+                               , "iframe_bracket_form"+                               , "igeowedge_flag"+                               , "imetric"+                               , "in_netmath"+                               , "inchar"+                               , "infeval"+                               , "inflag"+                               , "infolists"+                               , "integrate_use_rootsof"+                               , "integration_constant"+                               , "integration_constant_counter"+                               , "intfaclim"+                               , "isolate_wrt_times"+                               , "keepfloat"+                               , "labels"+                               , "let_rule_packages"+                               , "letrat"+                               , "lhospitallim"+                               , "limsubst"+                               , "linechar"+                               , "linel"+                               , "linenum"+                               , "linsolve_params"+                               , "linsolvewarn"+                               , "lispdisp"+                               , "listarith"+                               , "listconstvars"+                               , "listdummyvars"+                               , "lmxchar"+                               , "loadprint"+                               , "logabs"+                               , "logarc"+                               , "logconcoeffp"+                               , "logexpand"+                               , "lognegint"+                               , "lognumer"+                               , "logsimp"+                               , "m1pbranch"+                               , "macroexpansion"+                               , "maperror"+                               , "mapprint"+                               , "matrix_element_add"+                               , "matrix_element_mult"+                               , "matrix_element_transpose"+                               , "maxapplydepth"+                               , "maxapplyheight"+                               , "maxima_tempdir"+                               , "maxima_userdir"+                               , "maxnegex"+                               , "maxposex"+                               , "maxpsifracdenom"+                               , "maxpsifracnum"+                               , "maxpsinegint"+                               , "maxpsiposint"+                               , "maxtayorder"+                               , "method"+                               , "mode_check_errorp"+                               , "mode_check_warnp"+                               , "mode_checkp"+                               , "modulus"+                               , "multiplicities"+                               , "myoptions"+                               , "negdistrib"+                               , "negsumdispflag"+                               , "newtonepsilon"+                               , "newtonmaxiter"+                               , "niceindicespref"+                               , "nolabels"+                               , "nonegative_lp"+                               , "noundisp"+                               , "obase"+                               , "opproperties"+                               , "opsubst"+                               , "optimprefix"+                               , "optionset"+                               , "outchar"+                               , "packagefile"+                               , "partswitch"+                               , "pfeformat"+                               , "piece"+                               , "plot_options"+                               , "poislim"+                               , "poly_coefficient_ring"+                               , "poly_elimination_order"+                               , "poly_grobner_algorithm"+                               , "poly_grobner_debug"+                               , "poly_monomial_order"+                               , "poly_primary_elimination_order"+                               , "poly_return_term_list"+                               , "poly_secondary_elimination_order"+                               , "poly_top_reduction_only"+                               , "powerdisp"+                               , "prederror"+                               , "primep_number_of_tests"+                               , "product_use_gamma"+                               , "programmode"+                               , "prompt"+                               , "psexpand"+                               , "radexpand"+                               , "radsubstflag"+                               , "random_beta_algorithm"+                               , "random_binomial_algorithm"+                               , "random_chi2_algorithm"+                               , "random_exp_algorithm"+                               , "random_f_algorithm"+                               , "random_gamma_algorithm"+                               , "random_geometric_algorithm"+                               , "random_hypergeometric_algorithm"+                               , "random_negative_binomial_algorithm"+                               , "random_normal_algorithm"+                               , "random_poisson_algorithm"+                               , "random_student_t_algorithm"+                               , "ratalgdenom"+                               , "ratchristof"+                               , "ratdenomdivide"+                               , "rateinstein"+                               , "ratepsilon"+                               , "ratexpand"+                               , "ratfac"+                               , "ratmx"+                               , "ratprint"+                               , "ratriemann"+                               , "ratsimpexpons"+                               , "ratvars"+                               , "ratweights"+                               , "ratweyl"+                               , "ratwtlvl"+                               , "realonly"+                               , "refcheck"+                               , "rmxchar"+                               , "rombergabs"+                               , "rombergit"+                               , "rombergmin"+                               , "rombergtol"+                               , "rootsconmode"+                               , "rootsepsilon"+                               , "savedef"+                               , "savefactors"+                               , "scalarmatrixp"+                               , "setcheck"+                               , "setcheckbreak"+                               , "setval"+                               , "showtime"+                               , "simplify_products"+                               , "simpsum"+                               , "sinnpiflag"+                               , "solve_inconsistent_error"+                               , "solvedecomposes"+                               , "solveexplicit"+                               , "solvefactors"+                               , "solvenullwarn"+                               , "solveradcan"+                               , "solvetrigwarn"+                               , "sparse"+                               , "sqrtdispflag"+                               , "stardisp"+                               , "stats_numer"+                               , "stringdisp"+                               , "sublis_apply_lambda"+                               , "sumexpand"+                               , "sumsplitfact"+                               , "taylor_logexpand"+                               , "taylor_order_coefficients"+                               , "taylor_truncate_polynomials"+                               , "taylordepth"+                               , "tensorkill"+                               , "testsuite_files"+                               , "timer_devalue"+                               , "tlimswitch"+                               , "tr_array_as_ref"+                               , "tr_bound_function_applyp"+                               , "tr_file_tty_messagesp"+                               , "tr_float_can_branch_complex"+                               , "tr_function_call_default"+                               , "tr_numer"+                               , "tr_optimize_max_loop"+                               , "tr_semicompile"+                               , "tr_state_vars"+                               , "tr_warn_bad_function_calls"+                               , "tr_warn_fexpr"+                               , "tr_warn_meval"+                               , "tr_warn_mode"+                               , "tr_warn_undeclared"+                               , "tr_warn_undefined_variable"+                               , "tr_windy"+                               , "transcompile"+                               , "transrun"+                               , "trigexpandplus"+                               , "trigexpandtimes"+                               , "triginverses"+                               , "trigsign"+                               , "ttyoff"+                               , "use_fast_arrays"+                               , "values"+                               , "vect_cross"+                               , "verbose"+                               , "zerobern"+                               , "zeta%pi"+                               ])+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !#&()*+,-./:;<=>?@[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "and"+                               , "do"+                               , "else"+                               , "elseif"+                               , "false"+                               , "for"+                               , "if"+                               , "in"+                               , "not"+                               , "or"+                               , "step"+                               , "then"+                               , "thru"+                               , "true"+                               , "while"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Maxima" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Maxima" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z_][a-zA-Z0-9%_]*"+                              , reCompiled = Just (compileRegex True "[a-zA-Z_][a-zA-Z0-9%_]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ConstantTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[-+]?\\d+\\.\\d*([BbDdEeSs][-+]?\\d+)?"+                              , reCompiled =+                                  Just (compileRegex True "[-+]?\\d+\\.\\d*([BbDdEeSs][-+]?\\d+)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[-+]?\\.\\d+([BbDdEeSs][-+]?\\d+)?"+                              , reCompiled =+                                  Just (compileRegex True "[-+]?\\.\\d+([BbDdEeSs][-+]?\\d+)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[-+]?\\d+[BbDdEeSs][-+]?\\d+"+                              , reCompiled =+                                  Just (compileRegex True "[-+]?\\d+[BbDdEeSs][-+]?\\d+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[-+]?\\d+"+                              , reCompiled = Just (compileRegex True "[-+]?\\d+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = DocumentationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Maxima"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Alexey Beshenov <al@beshenov.ru>"+  , sVersion = "3"+  , sLicense = "LGPLv2.1+"+  , sExtensions = [ "*.mac" , "*.MAC" , "*.dem" , "*.DEM" ]+  , sStartingContext = "Normal Text"+  }
+ src/Skylighting/Syntax/Mediawiki.hs view
@@ -0,0 +1,6208 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Mediawiki (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex++syntax :: Syntax+syntax = Syntax+  { sName = "MediaWiki"+  , sFilename = "mediawiki.xml"+  , sShortname = "Mediawiki"+  , sContexts =+      fromList+        [ ( "Bold"+          , Context+              { cName = "Bold"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "'''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "BoldItalic" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<u *>"+                              , reCompiled = Just (compileRegex True "<u *>")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "BoldUnderlined" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindWikiLinkBeingBold" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "BoldItalic"+          , Context+              { cName = "BoldItalic"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<u *>"+                              , reCompiled = Just (compileRegex True "<u *>")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "BoldItalicUnderlined" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindWikiLinkBeingBoldItalic" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "BoldItalicUnderlined"+          , Context+              { cName = "BoldItalicUnderlined"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</u *>"+                              , reCompiled = Just (compileRegex True "</u *>")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules+                            ( "MediaWiki" , "FindWikiLinkBeingBoldItalicUnderlined" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "BoldUnderlined"+          , Context+              { cName = "BoldUnderlined"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</u *>"+                              , reCompiled = Just (compileRegex True "</u *>")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "BoldUnderlinedItalic" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindWikiLinkBeingBoldUnderlined" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "BoldUnderlinedItalic"+          , Context+              { cName = "BoldUnderlinedItalic"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules+                            ( "MediaWiki" , "FindWikiLinkBeingBoldItalicUnderlined" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DefinitionListHeader"+          , Context+              { cName = "DefinitionListHeader"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DelimitedURL"+          , Context+              { cName = "DelimitedURL"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(http:|https:|ftp:|mailto:)[^]| ]*(?=$|[]|\\s])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(http:|https:|ftp:|mailto:)[^]| ]*(?=$|[]|\\s])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "DelimitedUrlLink" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ' '+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "URLTag" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DelimitedUrlLink"+          , Context+              { cName = "DelimitedUrlLink"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ' '+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindHtmlEntities"+          , Context+              { cName = "FindHtmlEntities"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "&(#[0-9]+|#[xX][0-9A-Fa-f]+|(?![0-9])[\\w_:][\\w.:_-]*);"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "&(#[0-9]+|#[xX][0-9A-Fa-f]+|(?![0-9])[\\w_:][\\w.:_-]*);")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindHtmlStartTagAttributes"+          , Context+              { cName = "FindHtmlStartTagAttributes"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(?![0-9])[\\w_:][\\w.:_-]*"+                              , reCompiled =+                                  Just (compileRegex True "(?![0-9])[\\w_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "MediaWiki" , "HtmlAttribute" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+(?![0-9])[\\w_:][\\w.:_-]*"+                              , reCompiled =+                                  Just (compileRegex True "\\s+(?![0-9])[\\w_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "HtmlAttribute" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindListItem"+          , Context+              { cName = "FindListItem"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[*#;:\\s]*[*#:]+"+                              , reCompiled = Just (compileRegex True "[*#;:\\s]*[*#:]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindSyntaxHighlightingHtmlElement"+          , Context+              { cName = "FindSyntaxHighlightingHtmlElement"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<source(?=\\s)"+                              , reCompiled = Just (compileRegex True "<source(?=\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "SourceStartTag" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<syntaxhighlight(?=\\s)"+                              , reCompiled = Just (compileRegex True "<syntaxhighlight(?=\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "SyntaxHighlightStartTag" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindTable"+          , Context+              { cName = "FindTable"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '{' '|'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "MediaWiki" , "TableHeader" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindTemplate"+          , Context+              { cName = "FindTemplate"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '{' '{'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "Template" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindTextDecorations"+          , Context+              { cName = "FindTextDecorations"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "'''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "Bold" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "Italic" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<u *>"+                              , reCompiled = Just (compileRegex True "<u *>")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "Underlined" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindTextDecorationsInHeader"+          , Context+              { cName = "FindTextDecorationsInHeader"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "'''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "Bold" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "BoldItalic" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindUrl"+          , Context+              { cName = "FindUrl"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[(http:|https:|ftp:|mailto:)[^]| ]*(?=$|[]|\\s])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\[(http:|https:|ftp:|mailto:)[^]| ]*(?=$|[]|\\s])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "DelimitedURL" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(http:|https:|ftp:|mailto:)[^]| ]*(?=$|[]|\\s])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(http:|https:|ftp:|mailto:)[^]| ]*(?=$|[]|\\s])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "LooseURL" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindUrlWithinTemplate"+          , Context+              { cName = "FindUrlWithinTemplate"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[(http:|https:|ftp:|mailto:)[^]| ]*(?=$|[]|\\s])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\[(http:|https:|ftp:|mailto:)[^]| ]*(?=$|[]|\\s])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "DelimitedURL" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(http:|https:|ftp:|mailto:)[^]| ]*(?=$|[]|\\s])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(http:|https:|ftp:|mailto:)[^]| ]*(?=$|[]|\\s])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "LooseURLWithinTemplate" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindWikiLink"+          , Context+              { cName = "FindWikiLink"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '[' '['+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "WikiLink" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindWikiLinkBeingBold"+          , Context+              { cName = "FindWikiLinkBeingBold"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[\\[[^]|]*\\|[^]]*\\]\\]"+                              , reCompiled =+                                  Just (compileRegex True "\\[\\[[^]|]*\\|[^]]*\\]\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "WikiLinkBoldWithDescription" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[\\[[^]|]*\\]\\]"+                              , reCompiled = Just (compileRegex True "\\[\\[[^]|]*\\]\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "WikiLinkBoldWithoutDescription" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindWikiLinkBeingBoldItalic"+          , Context+              { cName = "FindWikiLinkBeingBoldItalic"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[\\[[^]|]*\\|[^]]*\\]\\]"+                              , reCompiled =+                                  Just (compileRegex True "\\[\\[[^]|]*\\|[^]]*\\]\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "WikiLinkBoldItalicWithDescription" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[\\[[^]|]*\\]\\]"+                              , reCompiled = Just (compileRegex True "\\[\\[[^]|]*\\]\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "WikiLinkBoldItalicWithoutDescription" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindWikiLinkBeingBoldItalicUnderlined"+          , Context+              { cName = "FindWikiLinkBeingBoldItalicUnderlined"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[\\[[^]|]*\\|[^]]*\\]\\]"+                              , reCompiled =+                                  Just (compileRegex True "\\[\\[[^]|]*\\|[^]]*\\]\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push+                              ( "MediaWiki" , "WikiLinkBoldItalicUnderlinedWithDescription" )+                          ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[\\[[^]|]*\\]\\]"+                              , reCompiled = Just (compileRegex True "\\[\\[[^]|]*\\]\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push+                              ( "MediaWiki" , "WikiLinkBoldItalicUnderlinedWithoutDescription" )+                          ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindWikiLinkBeingBoldUnderlined"+          , Context+              { cName = "FindWikiLinkBeingBoldUnderlined"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[\\[[^]|]*\\|[^]]*\\]\\]"+                              , reCompiled =+                                  Just (compileRegex True "\\[\\[[^]|]*\\|[^]]*\\]\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "WikiLinkBoldUnderlinedWithDescription" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[\\[[^]|]*\\]\\]"+                              , reCompiled = Just (compileRegex True "\\[\\[[^]|]*\\]\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "WikiLinkBoldUnderlinedWithoutDescription" )+                          ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindWikiLinkBeingItalic"+          , Context+              { cName = "FindWikiLinkBeingItalic"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[\\[[^]|]*\\|[^]]*\\]\\]"+                              , reCompiled =+                                  Just (compileRegex True "\\[\\[[^]|]*\\|[^]]*\\]\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "WikiLinkItalicWithDescription" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[\\[[^]|]*\\]\\]"+                              , reCompiled = Just (compileRegex True "\\[\\[[^]|]*\\]\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "WikiLinkItalicWithoutDescription" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindWikiLinkBeingItalicUnderlined"+          , Context+              { cName = "FindWikiLinkBeingItalicUnderlined"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[\\[[^]|]*\\|[^]]*\\]\\]"+                              , reCompiled =+                                  Just (compileRegex True "\\[\\[[^]|]*\\|[^]]*\\]\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "WikiLinkItalicUnderlinedWithDescription" )+                          ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[\\[[^]|]*\\]\\]"+                              , reCompiled = Just (compileRegex True "\\[\\[[^]|]*\\]\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push+                              ( "MediaWiki" , "WikiLinkItalicUnderlinedWithoutDescription" )+                          ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindWikiLinkBeingUnderlined"+          , Context+              { cName = "FindWikiLinkBeingUnderlined"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[\\[[^]|]*\\|[^]]*\\]\\]"+                              , reCompiled =+                                  Just (compileRegex True "\\[\\[[^]|]*\\|[^]]*\\]\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "WikiLinkUnderlinedWithDescription" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[\\[[^]|]*\\]\\]"+                              , reCompiled = Just (compileRegex True "\\[\\[[^]|]*\\]\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "WikiLinkUnderlinedWithoutDescription" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "HtmlAttribute"+          , Context+              { cName = "HtmlAttribute"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "HtmlValue" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "HtmlValue"+          , Context+              { cName = "HtmlValue"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "ValueWithDoubleQuotes" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "ValueWithSingleQuotes" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Italic"+          , Context+              { cName = "Italic"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "'''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "ItalicBold" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<u *>"+                              , reCompiled = Just (compileRegex True "<u *>")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "ItalicUnderlined" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindWikiLinkBeingItalic" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ItalicBold"+          , Context+              { cName = "ItalicBold"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "'''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<u *>"+                              , reCompiled = Just (compileRegex True "<u *>")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "BoldItalicUnderlined" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindWikiLinkBeingBoldItalic" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ItalicUnderlined"+          , Context+              { cName = "ItalicUnderlined"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</u *>"+                              , reCompiled = Just (compileRegex True "</u *>")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "'''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "ItalicUnderlinedBold" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindWikiLinkBeingItalicUnderlined" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ItalicUnderlinedBold"+          , Context+              { cName = "ItalicUnderlinedBold"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "'''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules+                            ( "MediaWiki" , "FindWikiLinkBeingBoldItalicUnderlined" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "JavaScriptSourceContent"+          , Context+              { cName = "JavaScriptSourceContent"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "SourceEnd" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "JavaScript" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "JavaScriptSourceStartTag"+          , Context+              { cName = "JavaScriptSourceStartTag"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "JavaScriptSourceContent" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindHtmlStartTagAttributes" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "JavaScriptSyntaxHighlightContent"+          , Context+              { cName = "JavaScriptSyntaxHighlightContent"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "</syntaxhighlight>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "SyntaxHighlightEnd" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "JavaScript" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "JavaScriptSyntaxHighlightStartTag"+          , Context+              { cName = "JavaScriptSyntaxHighlightStartTag"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "JavaScriptSyntaxHighlightContent" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindHtmlStartTagAttributes" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "LooseURL"+          , Context+              { cName = "LooseURL"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ' '+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "LooseURLWithinTemplate"+          , Context+              { cName = "LooseURLWithinTemplate"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '}' '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar ' '+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "NoWiki"+          , Context+              { cName = "NoWiki"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<!--[^-]*-->"+                              , reCompiled = Just (compileRegex True "<!--[^-]*-->")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "</nowiki>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[<][^>]+[>]"+                              , reCompiled = Just (compileRegex True "[<][^>]+[>]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<pre>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "Pre" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Pre"+          , Context+              { cName = "Pre"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "</pre>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Section2"+          , Context+              { cName = "Section2"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[~]{3,4}"+                              , reCompiled = Just (compileRegex True "[~]{3,4}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindUrl" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindTextDecorationsInHeader" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "{{{"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "TemplateParameter" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindWikiLink" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindHtmlEntities" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<nowiki>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "NoWiki" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<pre>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "Pre" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindSyntaxHighlightingHtmlElement" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[<][^>]+[>]"+                              , reCompiled = Just (compileRegex True "[<][^>]+[>]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "={3,} *$"+                              , reCompiled = Just (compileRegex True "={3,} *$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "={2,2} *$"+                              , reCompiled = Just (compileRegex True "={2,2} *$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "={1,1} *$"+                              , reCompiled = Just (compileRegex True "={1,1} *$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "=*[^=]+$"+                              , reCompiled = Just (compileRegex True "=*[^=]+$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Section3"+          , Context+              { cName = "Section3"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[~]{3,4}"+                              , reCompiled = Just (compileRegex True "[~]{3,4}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindUrl" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindTextDecorationsInHeader" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "{{{"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "TemplateParameter" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindWikiLink" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindHtmlEntities" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<nowiki>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "NoWiki" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<pre>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "Pre" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindSyntaxHighlightingHtmlElement" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[<][^>]+[>]"+                              , reCompiled = Just (compileRegex True "[<][^>]+[>]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "={4,} *$"+                              , reCompiled = Just (compileRegex True "={4,} *$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "={3,3} *$"+                              , reCompiled = Just (compileRegex True "={3,3} *$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "={1,2} *$"+                              , reCompiled = Just (compileRegex True "={1,2} *$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "=*[^=]+$"+                              , reCompiled = Just (compileRegex True "=*[^=]+$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Section4"+          , Context+              { cName = "Section4"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[~]{3,4}"+                              , reCompiled = Just (compileRegex True "[~]{3,4}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindUrl" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindTextDecorationsInHeader" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "{{{"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "TemplateParameter" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindWikiLink" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindHtmlEntities" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<nowiki>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "NoWiki" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<pre>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "Pre" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindSyntaxHighlightingHtmlElement" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[<][^>]+[>]"+                              , reCompiled = Just (compileRegex True "[<][^>]+[>]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "={5,} *$"+                              , reCompiled = Just (compileRegex True "={5,} *$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "={4,4} *$"+                              , reCompiled = Just (compileRegex True "={4,4} *$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "={1,3} *$"+                              , reCompiled = Just (compileRegex True "={1,3} *$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "=*[^=]+$"+                              , reCompiled = Just (compileRegex True "=*[^=]+$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Section5"+          , Context+              { cName = "Section5"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[~]{3,4}"+                              , reCompiled = Just (compileRegex True "[~]{3,4}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindUrl" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindTextDecorationsInHeader" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "{{{"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "TemplateParameter" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindWikiLink" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindHtmlEntities" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<nowiki>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "NoWiki" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<pre>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "Pre" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindSyntaxHighlightingHtmlElement" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[<][^>]+[>]"+                              , reCompiled = Just (compileRegex True "[<][^>]+[>]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "={6,} *$"+                              , reCompiled = Just (compileRegex True "={6,} *$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "={5,5} *$"+                              , reCompiled = Just (compileRegex True "={5,5} *$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "={1,4} *$"+                              , reCompiled = Just (compileRegex True "={1,4} *$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "={1,4} *$"+                              , reCompiled = Just (compileRegex True "={1,4} *$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "=*[^=]+$"+                              , reCompiled = Just (compileRegex True "=*[^=]+$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SourceEnd"+          , Context+              { cName = "SourceEnd"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "</source>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SourceStartTag"+          , Context+              { cName = "SourceStartTag"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(^|\\s+)lang\\=(\"javascript\"|'javascript')"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(^|\\s+)lang\\=(\"javascript\"|'javascript')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "JavaScriptSourceStartTag" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "UnsupportedLanguageSourceStartTag" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindHtmlStartTagAttributes" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SyntaxHighlightEnd"+          , Context+              { cName = "SyntaxHighlightEnd"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "</syntaxhighlight>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SyntaxHighlightStartTag"+          , Context+              { cName = "SyntaxHighlightStartTag"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(^|\\s+)lang\\=(\"javascript\"|'javascript')"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(^|\\s+)lang\\=(\"javascript\"|'javascript')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "JavaScriptSyntaxHighlightStartTag" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push+                              ( "MediaWiki" , "UnsupportedLanguageSyntaxHighlightStartTag" )+                          ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindHtmlStartTagAttributes" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "TableContent"+          , Context+              { cName = "TableContent"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[=]{5,5}(?!=)"+                              , reCompiled = Just (compileRegex True "[=]{5,5}(?!=)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "MediaWiki" , "Section5" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[=]{4,4}(?!=)"+                              , reCompiled = Just (compileRegex True "[=]{4,4}(?!=)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "MediaWiki" , "Section4" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[=]{3,3}(?!=)"+                              , reCompiled = Just (compileRegex True "[=]{3,3}(?!=)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "MediaWiki" , "Section3" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[=]{2,2}(?!=)"+                              , reCompiled = Just (compileRegex True "[=]{2,2}(?!=)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "MediaWiki" , "Section2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "DefinitionListHeader" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindListItem" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindUrl" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTextDecorations" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTable" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '|' '}'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '|' '-'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '|'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "{{{"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "TemplateParameter" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindWikiLink" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindHtmlEntities" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<nowiki>"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "NoWiki" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<pre>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "Pre" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindSyntaxHighlightingHtmlElement" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[<][^>]+[>]"+                              , reCompiled = Just (compileRegex True "[<][^>]+[>]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\s]"+                              , reCompiled = Just (compileRegex True "[\\s]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "MediaWiki" , "Unformatted" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[~]{3,4}"+                              , reCompiled = Just (compileRegex True "[~]{3,4}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[-]{4,}"+                              , reCompiled = Just (compileRegex True "[-]{4,}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '!'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "TableHeader"+          , Context+              { cName = "TableHeader"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '{' '|'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindHtmlStartTagAttributes" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "MediaWiki" , "TableContent" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Template"+          , Context+              { cName = "Template"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "|"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "TemplateParameterSlot" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '}' '}'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "TemplateParameter"+          , Context+              { cName = "TemplateParameter"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "}}}"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "TemplateParameterSlot"+          , Context+              { cName = "TemplateParameterSlot"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '}' '}'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[~]{3,4}"+                              , reCompiled = Just (compileRegex True "[~]{3,4}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindListItem" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindUrlWithinTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTextDecorations" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "{{{"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "TemplateParameter" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindWikiLink" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindHtmlEntities" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<nowiki>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "NoWiki" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<pre>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "Pre" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindSyntaxHighlightingHtmlElement" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[<][^>]+[>]"+                              , reCompiled = Just (compileRegex True "[<][^>]+[>]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "|"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^{}|=]+(?=[=])"+                              , reCompiled = Just (compileRegex True "[^{}|=]+(?=[=])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "TemplateParameterSlotEqual" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "TemplateParameterSlotEqual"+          , Context+              { cName = "TemplateParameterSlotEqual"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '}' '}'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "|"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "="+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "TemplateParameterSlotValue" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "TemplateParameterSlotValue"+          , Context+              { cName = "TemplateParameterSlotValue"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[~]{3,4}"+                              , reCompiled = Just (compileRegex True "[~]{3,4}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindListItem" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindUrlWithinTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTextDecorations" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "{{{"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "TemplateParameter" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindWikiLink" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindHtmlEntities" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<nowiki>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "NoWiki" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<pre>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "Pre" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindSyntaxHighlightingHtmlElement" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[<][^>]+[>]"+                              , reCompiled = Just (compileRegex True "[<][^>]+[>]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '}' '}'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "|"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "URLTag"+          , Context+              { cName = "URLTag"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTextDecorations" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Underlined"+          , Context+              { cName = "Underlined"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "'''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "UnderlinedBold" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "UnderlinedItalic" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</u *>"+                              , reCompiled = Just (compileRegex True "</u *>")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindWikiLinkBeingUnderlined" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "UnderlinedBold"+          , Context+              { cName = "UnderlinedBold"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "'''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "BoldUnderlinedItalic" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindWikiLinkBeingBoldUnderlined" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "UnderlinedItalic"+          , Context+              { cName = "UnderlinedItalic"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "'''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "ItalicUnderlinedBold" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindWikiLinkBeingItalicUnderlined" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Unformatted"+          , Context+              { cName = "Unformatted"+              , cSyntax = "MediaWiki"+              , cRules = []+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "UnsupportedLanguageSourceContent"+          , Context+              { cName = "UnsupportedLanguageSourceContent"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "SourceEnd" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "UnsupportedLanguageSourceStartTag"+          , Context+              { cName = "UnsupportedLanguageSourceStartTag"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "UnsupportedLanguageSourceContent" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindHtmlStartTagAttributes" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "UnsupportedLanguageSyntaxHighlightContent"+          , Context+              { cName = "UnsupportedLanguageSyntaxHighlightContent"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "SyntaxHighlightEnd" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "UnsupportedLanguageSyntaxHighlightStartTag"+          , Context+              { cName = "UnsupportedLanguageSyntaxHighlightStartTag"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push+                              ( "MediaWiki" , "UnsupportedLanguageSyntaxHighlightContent" )+                          ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindHtmlStartTagAttributes" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ValueWithDoubleQuotes"+          , Context+              { cName = "ValueWithDoubleQuotes"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindHtmlEntities" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ValueWithSingleQuotes"+          , Context+              { cName = "ValueWithSingleQuotes"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindHtmlEntities" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLink"+          , Context+              { cName = "WikiLink"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkWithDescriptionRules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '|'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "WikiLinkDescription" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkBoldItalicUnderlinedWithDescription"+          , Context+              { cName = "WikiLinkBoldItalicUnderlinedWithDescription"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkWithDescriptionRules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '|'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "WikiLinkDescriptionBoldItalicUnderlined" )+                          ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkBoldItalicUnderlinedWithoutDescription"+          , Context+              { cName = "WikiLinkBoldItalicUnderlinedWithoutDescription"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkWithoutDescriptionRules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkBoldItalicWithDescription"+          , Context+              { cName = "WikiLinkBoldItalicWithDescription"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkWithDescriptionRules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '|'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "WikiLinkDescriptionBoldItalic" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkBoldItalicWithoutDescription"+          , Context+              { cName = "WikiLinkBoldItalicWithoutDescription"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkWithoutDescriptionRules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkBoldUnderlinedWithDescription"+          , Context+              { cName = "WikiLinkBoldUnderlinedWithDescription"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkWithDescriptionRules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '|'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "WikiLinkDescriptionBoldUnderlined" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkBoldUnderlinedWithoutDescription"+          , Context+              { cName = "WikiLinkBoldUnderlinedWithoutDescription"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkWithoutDescriptionRules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkBoldWithDescription"+          , Context+              { cName = "WikiLinkBoldWithDescription"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkWithDescriptionRules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '|'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "WikiLinkDescriptionBold" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkBoldWithoutDescription"+          , Context+              { cName = "WikiLinkBoldWithoutDescription"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkWithoutDescriptionRules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkDescription"+          , Context+              { cName = "WikiLinkDescription"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkDescriptionRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTextDecorations" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkDescriptionBold"+          , Context+              { cName = "WikiLinkDescriptionBold"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkDescriptionRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "BoldItalic" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<u *>"+                              , reCompiled = Just (compileRegex True "<u *>")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "BoldUnderlined" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkDescriptionBoldItalic"+          , Context+              { cName = "WikiLinkDescriptionBoldItalic"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkDescriptionRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<u *>"+                              , reCompiled = Just (compileRegex True "<u *>")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "BoldItalicUnderlined" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkDescriptionBoldItalicUnderlined"+          , Context+              { cName = "WikiLinkDescriptionBoldItalicUnderlined"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkDescriptionRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkDescriptionBoldUnderlined"+          , Context+              { cName = "WikiLinkDescriptionBoldUnderlined"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkDescriptionRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "BoldUnderlinedItalic" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkDescriptionItalic"+          , Context+              { cName = "WikiLinkDescriptionItalic"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkDescriptionRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "'''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "ItalicBold" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<u *>"+                              , reCompiled = Just (compileRegex True "<u *>")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "ItalicUnderlined" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkDescriptionItalicUnderlined"+          , Context+              { cName = "WikiLinkDescriptionItalicUnderlined"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkDescriptionRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "'''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "ItalicUnderlinedBold" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkDescriptionRules"+          , Context+              { cName = "WikiLinkDescriptionRules"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindHtmlEntities" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars ']' ']'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkDescriptionUnderlined"+          , Context+              { cName = "WikiLinkDescriptionUnderlined"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkDescriptionRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "'''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "UnderlinedBold" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "''"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "UnderlinedItalic" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkItalicUnderlinedWithDescription"+          , Context+              { cName = "WikiLinkItalicUnderlinedWithDescription"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkWithDescriptionRules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '|'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "WikiLinkDescriptionItalicUnderlined" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkItalicUnderlinedWithoutDescription"+          , Context+              { cName = "WikiLinkItalicUnderlinedWithoutDescription"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkWithoutDescriptionRules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkItalicWithDescription"+          , Context+              { cName = "WikiLinkItalicWithDescription"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkWithDescriptionRules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '|'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "WikiLinkDescriptionItalic" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkItalicWithoutDescription"+          , Context+              { cName = "WikiLinkItalicWithoutDescription"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkWithoutDescriptionRules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkUnderlinedWithDescription"+          , Context+              { cName = "WikiLinkUnderlinedWithDescription"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkWithDescriptionRules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '|'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "WikiLinkDescriptionUnderlined" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkUnderlinedWithoutDescription"+          , Context+              { cName = "WikiLinkUnderlinedWithoutDescription"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkWithoutDescriptionRules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkWithDescriptionRules"+          , Context+              { cName = "WikiLinkWithDescriptionRules"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "WikiLinkWithoutDescriptionRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WikiLinkWithoutDescriptionRules"+          , Context+              { cName = "WikiLinkWithoutDescriptionRules"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindHtmlEntities" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '[' '['+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars ']' ']'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "comment"+          , Context+              { cName = "comment"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "-->"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "normal"+          , Context+              { cName = "normal"+              , cSyntax = "MediaWiki"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[=]{5,5}(?!=)"+                              , reCompiled = Just (compileRegex True "[=]{5,5}(?!=)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "MediaWiki" , "Section5" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[=]{4,4}(?!=)"+                              , reCompiled = Just (compileRegex True "[=]{4,4}(?!=)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "MediaWiki" , "Section4" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[=]{3,3}(?!=)"+                              , reCompiled = Just (compileRegex True "[=]{3,3}(?!=)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "MediaWiki" , "Section3" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[=]{2,2}(?!=)"+                              , reCompiled = Just (compileRegex True "[=]{2,2}(?!=)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "MediaWiki" , "Section2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[~]{3,4}"+                              , reCompiled = Just (compileRegex True "[~]{3,4}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch =+                          [ Push ( "MediaWiki" , "DefinitionListHeader" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindListItem" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindUrl" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTextDecorations" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTable" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "{{{"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "TemplateParameter" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindTemplate" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindWikiLink" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "MediaWiki" , "FindHtmlEntities" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<nowiki>"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "NoWiki" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<pre>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MediaWiki" , "Pre" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "MediaWiki" , "FindSyntaxHighlightingHtmlElement" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[<][^>]+[>]"+                              , reCompiled = Just (compileRegex True "[<][^>]+[>]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\s]"+                              , reCompiled = Just (compileRegex True "[\\s]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "MediaWiki" , "Unformatted" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = ""+  , sVersion = "3"+  , sLicense = "FDL"+  , sExtensions = [ "*.mediawiki" ]+  , sStartingContext = "normal"+  }
+ src/Skylighting/Syntax/Metafont.hs view
@@ -0,0 +1,1922 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Metafont (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Metapost/Metafont"+  , sFilename = "metafont.xml"+  , sShortname = "Metafont"+  , sContexts =+      fromList+        [ ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "Metapost/Metafont"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(FIXME|TODO):?"+                              , reCompiled = Just (compileRegex True "(FIXME|TODO):?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ContrSeq"+          , Context+              { cName = "ContrSeq"+              , cSyntax = "Metapost/Metafont"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "verb*"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Metapost/Metafont" , "Verb" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "verb(?=[^a-zA-Z])"+                              , reCompiled = Just (compileRegex True "verb(?=[^a-zA-Z])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Metapost/Metafont" , "Verb" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z]+(\\+?|\\*{0,3})"+                              , reCompiled = Just (compileRegex True "[a-zA-Z]+(\\+?|\\*{0,3})")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^a-zA-Z]"+                              , reCompiled = Just (compileRegex True "[^a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MathContrSeq"+          , Context+              { cName = "MathContrSeq"+              , cSyntax = "Metapost/Metafont"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z]+\\*?"+                              , reCompiled = Just (compileRegex True "[a-zA-Z]+\\*?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^a-zA-Z]"+                              , reCompiled = Just (compileRegex True "[^a-zA-Z]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MathMode"+          , Context+              { cName = "MathMode"+              , cSyntax = "Metapost/Metafont"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "$$"+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Metapost/Metafont" , "MathContrSeq" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ']'+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal Text"+          , Context+              { cName = "Normal Text"+              , cSyntax = "Metapost/Metafont"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "and"+                               , "charexists"+                               , "false"+                               , "known"+                               , "not"+                               , "odd"+                               , "or"+                               , "true"+                               , "unknown"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "abs"+                               , "angle"+                               , "ASCII"+                               , "ceiling"+                               , "cosd"+                               , "directiontime"+                               , "div"+                               , "dotprod"+                               , "floor"+                               , "hex"+                               , "length"+                               , "max"+                               , "mexp"+                               , "min"+                               , "mlog"+                               , "mod"+                               , "normaldeviate"+                               , "oct"+                               , "sind"+                               , "sqrt"+                               , "totalweight"+                               , "turningnumber"+                               , "uniformdeviate"+                               , "xpart"+                               , "xxpart"+                               , "xypart"+                               , "ypart"+                               , "yxpart"+                               , "yypart"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "autorounding"+                               , "boundarychar"+                               , "charcode"+                               , "chardp"+                               , "chardx"+                               , "chardy"+                               , "charext"+                               , "charht"+                               , "charic"+                               , "charwd"+                               , "day"+                               , "designsize"+                               , "fillin"+                               , "fontmaking"+                               , "granularity"+                               , "hppp"+                               , "month"+                               , "pausing"+                               , "proofing"+                               , "showstopping"+                               , "smoothing"+                               , "time"+                               , "tracingcapsules"+                               , "tracingchoices"+                               , "tracingcommands"+                               , "tracingedges"+                               , "tracingequations"+                               , "tracingmacros"+                               , "tracingonline"+                               , "tracingoutput"+                               , "tracingpens"+                               , "tracingrestores"+                               , "tracingspecs"+                               , "tracingstats"+                               , "tracingtitles"+                               , "turningcheck"+                               , "vppp"+                               , "warningcheck"+                               , "xoffset"+                               , "year"+                               , "yoffset"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "of"+                               , "penoffset"+                               , "point"+                               , "postcontrol"+                               , "precontrol"+                               , "rotated"+                               , "scaled"+                               , "shifted"+                               , "slanted"+                               , "transformed"+                               , "xscaled"+                               , "yscaled"+                               , "zscaled"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "atleast"+                               , "controls"+                               , "curl"+                               , "cycle"+                               , "makepath"+                               , "reverse"+                               , "subpath"+                               , "tension"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet False [ "makepen" , "nullpen" , "pencircle" ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet False [ "nullpicture" ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "char"+                               , "decimal"+                               , "jobname"+                               , "readstring"+                               , "str"+                               , "substring"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "addto"+                               , "also"+                               , "at"+                               , "batchmode"+                               , "contour"+                               , "cull"+                               , "delimiters"+                               , "display"+                               , "doublepath"+                               , "dropping"+                               , "dump"+                               , "end"+                               , "errhelp"+                               , "errmessage"+                               , "errorstopmode"+                               , "everyjob"+                               , "from"+                               , "interim"+                               , "inwindow"+                               , "keeping"+                               , "let"+                               , "message"+                               , "newinternal"+                               , "nonstopmode"+                               , "numspecial"+                               , "openwindow"+                               , "outer"+                               , "randomseed"+                               , "save"+                               , "scrollmode"+                               , "shipout"+                               , "show"+                               , "showdependencies"+                               , "showstats"+                               , "showtoken"+                               , "showvariable"+                               , "special"+                               , "to"+                               , "withpen"+                               , "withweight"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "boolean"+                               , "numeric"+                               , "pair"+                               , "path"+                               , "pen"+                               , "picture"+                               , "string"+                               , "transform"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "expr"+                               , "primary"+                               , "primarydef"+                               , "secondary"+                               , "secondarydef"+                               , "suffix"+                               , "tertiary"+                               , "tertiarydef"+                               , "text"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False [ "else" , "elseif" , "exitif" , "step" , "until" , "upto" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "charlist"+                               , "endinput"+                               , "expandafter"+                               , "extensible"+                               , "fontdimen"+                               , "headerbyte"+                               , "inner"+                               , "input"+                               , "intersectiontimes"+                               , "kern"+                               , "ligtable"+                               , "quote"+                               , "scantokens"+                               , "skipto"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "addto_currentpicture"+                               , "aspect_ratio"+                               , "base_name"+                               , "base_version"+                               , "blacker"+                               , "blankpicture"+                               , "bot"+                               , "bye"+                               , "byte"+                               , "capsule_def"+                               , "change_width"+                               , "clear_pen_memory"+                               , "clearit"+                               , "clearpen"+                               , "clearxy"+                               , "counterclockwise"+                               , "culldraw"+                               , "cullit"+                               , "currentpen"+                               , "currentpen_path"+                               , "currentpicture"+                               , "currenttransform"+                               , "currentwindow"+                               , "cutdraw"+                               , "cutoff"+                               , "d"+                               , "decr"+                               , "define_blacker_pixels"+                               , "define_corrected_pixels"+                               , "define_good_x_pixels"+                               , "define_good_y_pixels"+                               , "define_horizontal_corrected_pixels"+                               , "define_pixels"+                               , "define_whole_blacker_pixels"+                               , "define_whole_pixels"+                               , "define_whole_vertical_blacker_pixels"+                               , "define_whole_vertical_pixels"+                               , "dir"+                               , "direction"+                               , "directionpoint"+                               , "displaying"+                               , "ditto"+                               , "down"+                               , "downto"+                               , "draw"+                               , "drawdot"+                               , "eps"+                               , "epsilon"+                               , "erase"+                               , "exitunless"+                               , "extra_setup"+                               , "fill"+                               , "filldraw"+                               , "fix_units"+                               , "flex"+                               , "font_coding_scheme"+                               , "font_extra_space"+                               , "font_identifier"+                               , "font_normal_shrink"+                               , "font_normal_space"+                               , "font_normal_stretch"+                               , "font_quad"+                               , "font_setup"+                               , "font_size"+                               , "font_slant"+                               , "font_x_height"+                               , "fullcircle"+                               , "generate"+                               , "gfcorners"+                               , "gobble"+                               , "gobbled"+                               , "grayfont"+                               , "h"+                               , "halfcircle"+                               , "hide"+                               , "hround"+                               , "identity"+                               , "image_rules"+                               , "incr"+                               , "infinity"+                               , "interact"+                               , "interpath"+                               , "intersectionpoint"+                               , "inverse"+                               , "italcorr"+                               , "join_radius"+                               , "killtext"+                               , "labelfont"+                               , "labels"+                               , "left"+                               , "lft"+                               , "localfont"+                               , "loggingall"+                               , "lowres"+                               , "lowres_fix"+                               , "mag"+                               , "magstep"+                               , "makebox"+                               , "makegrid"+                               , "makelabel"+                               , "maketicks"+                               , "mode"+                               , "mode_def"+                               , "mode_name"+                               , "mode_setup"+                               , "nodisplays"+                               , "notransforms"+                               , "number_of_modes"+                               , "numtok"+                               , "o_correction"+                               , "openit"+                               , "origin"+                               , "pen_bot"+                               , "pen_lft"+                               , "pen_rt"+                               , "pen_top"+                               , "penlabels"+                               , "penpos"+                               , "penrazor"+                               , "penspeck"+                               , "pensquare"+                               , "penstroke"+                               , "pickup"+                               , "pixels_per_inch"+                               , "proof"+                               , "proofoffset"+                               , "proofrule"+                               , "proofrulethickness"+                               , "quartercircle"+                               , "range"+                               , "reflectedabout"+                               , "relax"+                               , "right"+                               , "rotatedabout"+                               , "rotatedaround"+                               , "round"+                               , "rt"+                               , "rulepen"+                               , "savepen"+                               , "screen_cols"+                               , "screen_rows"+                               , "screenchars"+                               , "screenrule"+                               , "screenstrokes"+                               , "shipit"+                               , "showit"+                               , "slantfont"+                               , "smode"+                               , "smoke"+                               , "softjoin"+                               , "solve"+                               , "stop"+                               , "superellipse"+                               , "takepower"+                               , "tensepath"+                               , "titlefont"+                               , "tolerance"+                               , "top"+                               , "tracingall"+                               , "tracingnone"+                               , "undraw"+                               , "undrawdot"+                               , "unfill"+                               , "unfilldraw"+                               , "unitpixel"+                               , "unitsquare"+                               , "unitvector"+                               , "up"+                               , "upto"+                               , "vround"+                               , "w"+                               , "whatever"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "bluepart"+                               , "clip"+                               , "color"+                               , "dashed"+                               , "fontsize"+                               , "greenpart"+                               , "infont"+                               , "linecap"+                               , "linejoin"+                               , "llcorner"+                               , "lrcorner"+                               , "miterlimit"+                               , "mpxbreak"+                               , "prologues"+                               , "redpart"+                               , "setbounds"+                               , "tracinglostchars"+                               , "truecorners"+                               , "ulcorner"+                               , "urcorner"+                               , "withcolor"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "ahangle"+                               , "ahlength"+                               , "arrowhead"+                               , "background"+                               , "base_name"+                               , "base_version"+                               , "bbox"+                               , "bboxmargin"+                               , "beveled"+                               , "black"+                               , "blacker"+                               , "blankpicture"+                               , "blue"+                               , "bot"+                               , "boxit"+                               , "boxjoin"+                               , "bpath"+                               , "buildcycle"+                               , "butt"+                               , "bye"+                               , "byte"+                               , "capsule_def"+                               , "center"+                               , "change_width"+                               , "circleit"+                               , "circmargin"+                               , "clear_pen_memory"+                               , "clearit"+                               , "clearpen"+                               , "clearxy"+                               , "counterclockwise"+                               , "cullit"+                               , "currentpen"+                               , "currentpen_path"+                               , "currentpicture"+                               , "currenttransform"+                               , "cutafter"+                               , "cutbefore"+                               , "cutdraw"+                               , "cuttings"+                               , "dashpattern"+                               , "decr"+                               , "defaultdx"+                               , "defaultdy"+                               , "defaultfont"+                               , "defaultpen"+                               , "defaultscale"+                               , "define_blacker_pixels"+                               , "define_corrected_pixels"+                               , "define_good_x_pixels"+                               , "define_good_y_pixels"+                               , "define_horizontal_corrected_pixels"+                               , "define_pixels"+                               , "define_whole_blacker_pixels"+                               , "define_whole_vertical_blacker_pixels"+                               , "define_whole_vertical_pixels"+                               , "dir"+                               , "direction"+                               , "directionpoint"+                               , "ditto"+                               , "dotlabel"+                               , "dotlabels"+                               , "down"+                               , "downto"+                               , "draw"+                               , "drawarrow"+                               , "drawboxed"+                               , "drawboxes"+                               , "drawdblarrow"+                               , "drawdot"+                               , "drawoptions"+                               , "drawunboxed"+                               , "EOF"+                               , "eps"+                               , "epsilon"+                               , "erase"+                               , "evenly"+                               , "exitunless"+                               , "extra_setup"+                               , "fill"+                               , "filldraw"+                               , "fixpos"+                               , "fixsize"+                               , "flex"+                               , "font_coding_scheme"+                               , "font_extra_space"+                               , "font_identifier"+                               , "font_normal_shrink"+                               , "font_normal_space"+                               , "font_normal_stretch"+                               , "font_quad"+                               , "font_size"+                               , "font_slant"+                               , "font_x_height"+                               , "fullcircle"+                               , "gfcorners"+                               , "gobble"+                               , "gobbled"+                               , "grayfont"+                               , "green"+                               , "halfcircle"+                               , "hide"+                               , "hround"+                               , "identity"+                               , "image"+                               , "imagerules"+                               , "incr"+                               , "infinity"+                               , "interact"+                               , "interpath"+                               , "intersectionpoint"+                               , "inverse"+                               , "italcorr"+                               , "label"+                               , "labelfont"+                               , "labeloffset"+                               , "labels"+                               , "left"+                               , "lft"+                               , "llft"+                               , "loggingall"+                               , "lowres_fix"+                               , "lrt"+                               , "magstep"+                               , "makebox"+                               , "makegrid"+                               , "makelabel"+                               , "maketicks"+                               , "mitered"+                               , "mode_def"+                               , "mode_setup"+                               , "nodisplays"+                               , "notransforms"+                               , "numeric_pickup"+                               , "numtok"+                               , "o_correction"+                               , "openit"+                               , "origin"+                               , "pen_bot"+                               , "pen_lft"+                               , "pen_rt"+                               , "pen_top"+                               , "penlabel"+                               , "penpos"+                               , "penrazor"+                               , "penspeck"+                               , "pensquare"+                               , "penstroke"+                               , "pic"+                               , "pickup"+                               , "proofoffset"+                               , "proofrule"+                               , "proofrulethickness"+                               , "quartercircle"+                               , "range"+                               , "red"+                               , "reflectedabout"+                               , "relax"+                               , "right"+                               , "rotatedabout"+                               , "rotatedaround"+                               , "round"+                               , "rounded"+                               , "rt"+                               , "rulepen"+                               , "savepen"+                               , "screenchars"+                               , "screenrule"+                               , "screenstrokes"+                               , "shipit"+                               , "showit"+                               , "slantfont"+                               , "smode"+                               , "softjoin"+                               , "solve"+                               , "squared"+                               , "stop"+                               , "superellipse"+                               , "takepower"+                               , "tensepath"+                               , "thelabel"+                               , "thru"+                               , "titlefont"+                               , "top"+                               , "tracingall"+                               , "tracingnone"+                               , "ulft"+                               , "undraw"+                               , "undrawdot"+                               , "unfill"+                               , "unfilldraw"+                               , "unitpixel"+                               , "unitsquare"+                               , "unitvector"+                               , "up"+                               , "upto"+                               , "urt"+                               , "vround"+                               , "whatever"+                               , "white"+                               , "withdots"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Metapost/Metafont" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Metapost/Metafont" , "string" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\+|\\-|\\*|\\/|\\=|\\:\\=)"+                              , reCompiled =+                                  Just (compileRegex True "(\\+|\\-|\\*|\\/|\\=|\\:\\=)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '.' '.'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(bp|cc|cm|dd|in|mm|pc|pt)\\b"+                              , reCompiled =+                                  Just (compileRegex True "\\b(bp|cc|cm|dd|in|mm|pc|pt)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b-?\\d+(bp|cc|cm|dd|in|mm|pc|pt)#?\\b"+                              , reCompiled =+                                  Just (compileRegex True "\\b-?\\d+(bp|cc|cm|dd|in|mm|pc|pt)#?\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b-?\\.\\d+(bp|cc|cm|dd|in|mm|pc|pt)#?\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex True "\\b-?\\.\\d+(bp|cc|cm|dd|in|mm|pc|pt)#?\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b-?\\d+\\.\\d+(bp|cc|cm|dd|in|mm|pc|pt)#?\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\b-?\\d+\\.\\d+(bp|cc|cm|dd|in|mm|pc|pt)#?\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[xy]\\d(\\w|\\')*"+                              , reCompiled = Just (compileRegex True "\\b[xy]\\d(\\w|\\')*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bz\\d(\\w|\\')*"+                              , reCompiled = Just (compileRegex True "\\bz\\d(\\w|\\')*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bp\\d(\\w|\\')*"+                              , reCompiled = Just (compileRegex True "\\bp\\d(\\w|\\')*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(verbatimtex|btex)\\b"+                              , reCompiled = Just (compileRegex False "\\b(verbatimtex|btex)\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Metapost/Metafont" , "TeXMode" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bbegin(group|fig|char)\\b"+                              , reCompiled =+                                  Just (compileRegex False "\\bbegin(group|fig|char)\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bend(group|fig|char)\\b"+                              , reCompiled =+                                  Just (compileRegex False "\\bend(group|fig|char)\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bextra_begin(group|fig|char)\\b"+                              , reCompiled =+                                  Just (compileRegex False "\\bextra_begin(group|fig|char)\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bextra_end(group|fig|char)\\b"+                              , reCompiled =+                                  Just (compileRegex False "\\bextra_end(group|fig|char)\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(def|vardef)\\b"+                              , reCompiled = Just (compileRegex False "\\b(def|vardef)\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\benddef\\b"+                              , reCompiled = Just (compileRegex False "\\benddef\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bif\\b"+                              , reCompiled = Just (compileRegex False "\\bif\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bfi\\b"+                              , reCompiled = Just (compileRegex False "\\bfi\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(for|forsuffixes|forever)\\b"+                              , reCompiled =+                                  Just (compileRegex False "\\b(for|forsuffixes|forever)\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bendfor\\b"+                              , reCompiled = Just (compileRegex False "\\bendfor\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "TeXMode"+          , Context+              { cName = "TeXMode"+              , cSyntax = "Metapost/Metafont"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Metapost/Metafont" , "ContrSeq" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Metapost/Metafont" , "MathMode" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "\\("+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Metapost/Metafont" , "MathMode" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\betex\\b"+                              , reCompiled = Just (compileRegex False "\\betex\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ToEndOfLine"+          , Context+              { cName = "ToEndOfLine"+              , cSyntax = "Metapost/Metafont"+              , cRules = []+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Verb"+          , Context+              { cName = "Verb"+              , cSyntax = "Metapost/Metafont"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(.)"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Metapost/Metafont" , "VerbEnd" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "VerbEnd"+          , Context+              { cName = "VerbEnd"+              , cSyntax = "Metapost/Metafont"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "%1"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\215'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^%1\\xd7]*"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "string"+          , Context+              { cName = "string"+              , cSyntax = "Metapost/Metafont"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Yedvilun (yedvilun@gmail.com)"+  , sVersion = "1"+  , sLicense = "LGPL"+  , sExtensions = [ "*.mp" , "*.mps" , "*.mpost" , "*.mf" ]+  , sStartingContext = "Normal Text"+  }
+ src/Skylighting/Syntax/Mips.hs view
@@ -0,0 +1,642 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Mips (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "MIPS Assembler"+  , sFilename = "mips.xml"+  , sShortname = "Mips"+  , sContexts =+      fromList+        [ ( "normal"+          , Context+              { cName = "normal"+              , cSyntax = "MIPS Assembler"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "abs.d"+                               , "abs.s"+                               , "add"+                               , "add.d"+                               , "add.s"+                               , "addi"+                               , "addiu"+                               , "addu"+                               , "and"+                               , "andi"+                               , "bc0f"+                               , "bc0t"+                               , "bc1f"+                               , "bc1t"+                               , "bc2f"+                               , "bc2t"+                               , "bc3f"+                               , "bc3t"+                               , "beq"+                               , "bgez"+                               , "bgezal"+                               , "bgtz"+                               , "blez"+                               , "bltz"+                               , "bltzal"+                               , "bne"+                               , "break"+                               , "c.eq.d"+                               , "c.eq.s"+                               , "c.le.d"+                               , "c.le.s"+                               , "c.lt.d"+                               , "c.lt.s"+                               , "c.ole.d"+                               , "c.ole.s"+                               , "c.olt.d"+                               , "c.olt.s"+                               , "c.seq.d"+                               , "c.seq.s"+                               , "c.ueq.d"+                               , "c.ueq.s"+                               , "c.ule.d"+                               , "c.ule.s"+                               , "c.ult.d"+                               , "c.ult.s"+                               , "c.un.d"+                               , "c.un.s"+                               , "cvt.d.s"+                               , "cvt.d.w"+                               , "cvt.s.d"+                               , "cvt.s.w"+                               , "cvt.w.d"+                               , "cvt.w.s"+                               , "div.d"+                               , "div.s"+                               , "j"+                               , "jal"+                               , "jalr"+                               , "jr"+                               , "lb"+                               , "lbu"+                               , "lh"+                               , "lhu"+                               , "lui"+                               , "lw"+                               , "lwc0"+                               , "lwc1"+                               , "lwc2"+                               , "lwc3"+                               , "lwl"+                               , "lwr"+                               , "mfc0"+                               , "mfc1"+                               , "mfc2"+                               , "mfc3"+                               , "mfhi"+                               , "mflo"+                               , "mtc0"+                               , "mtc1"+                               , "mtc2"+                               , "mtc3"+                               , "mthi"+                               , "mtlo"+                               , "mul.d"+                               , "mul.s"+                               , "mult"+                               , "multu"+                               , "nor"+                               , "or"+                               , "ori"+                               , "rfe"+                               , "sb"+                               , "sh"+                               , "sll"+                               , "sllv"+                               , "slt"+                               , "slti"+                               , "sltiu"+                               , "sra"+                               , "srav"+                               , "srl"+                               , "srlv"+                               , "sub"+                               , "sub.d"+                               , "sub.s"+                               , "subu"+                               , "sw"+                               , "swc0"+                               , "swc1"+                               , "swc2"+                               , "swc3"+                               , "swcl"+                               , "swl"+                               , "swr"+                               , "syscall"+                               , "xor"+                               , "xori"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "abs"+                               , "b"+                               , "beqz"+                               , "bge"+                               , "bgeu"+                               , "bgt"+                               , "bgtu"+                               , "ble"+                               , "bleu"+                               , "blt"+                               , "bltu"+                               , "bnez"+                               , "div"+                               , "divu"+                               , "l.d"+                               , "l.s"+                               , "la"+                               , "ld"+                               , "li"+                               , "li.d"+                               , "li.s"+                               , "mfc0.d"+                               , "mfc1.d"+                               , "mfc2.d"+                               , "mfc3.d"+                               , "mov.d"+                               , "mov.s"+                               , "move"+                               , "mul"+                               , "mulo"+                               , "mulou"+                               , "neg"+                               , "neg.d"+                               , "neg.s"+                               , "negu"+                               , "nop"+                               , "not"+                               , "rem"+                               , "remu"+                               , "rol"+                               , "ror"+                               , "s.d"+                               , "s.s"+                               , "sd"+                               , "seq"+                               , "sge"+                               , "sgeu"+                               , "sgt"+                               , "sgtu"+                               , "sle"+                               , "sleu"+                               , "sne"+                               , "ulh"+                               , "ulhu"+                               , "ulw"+                               , "ush"+                               , "usw"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "$0"+                               , "$1"+                               , "$10"+                               , "$11"+                               , "$12"+                               , "$13"+                               , "$14"+                               , "$15"+                               , "$16"+                               , "$17"+                               , "$18"+                               , "$19"+                               , "$2"+                               , "$20"+                               , "$21"+                               , "$22"+                               , "$23"+                               , "$24"+                               , "$25"+                               , "$26"+                               , "$27"+                               , "$28"+                               , "$29"+                               , "$3"+                               , "$30"+                               , "$31"+                               , "$4"+                               , "$5"+                               , "$6"+                               , "$7"+                               , "$8"+                               , "$9"+                               , "$t0"+                               , "$t1"+                               , "$t2"+                               , "$t3"+                               , "$t4"+                               , "$t5"+                               , "$t6"+                               , "$t7"+                               , "$t8"+                               , "$t9"+                               , "$zero"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "$a0"+                               , "$a1"+                               , "$a2"+                               , "$a3"+                               , "$at"+                               , "$fp"+                               , "$gp"+                               , "$k0"+                               , "$k1"+                               , "$ra"+                               , "$s0"+                               , "$s1"+                               , "$s2"+                               , "$s3"+                               , "$s4"+                               , "$s5"+                               , "$s6"+                               , "$s7"+                               , "$sp"+                               , "$v0"+                               , "$v1"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "$f0"+                               , "$f1"+                               , "$f10"+                               , "$f11"+                               , "$f12"+                               , "$f13"+                               , "$f14"+                               , "$f15"+                               , "$f16"+                               , "$f17"+                               , "$f18"+                               , "$f19"+                               , "$f2"+                               , "$f20"+                               , "$f21"+                               , "$f22"+                               , "$f23"+                               , "$f24"+                               , "$f25"+                               , "$f26"+                               , "$f27"+                               , "$f28"+                               , "$f29"+                               , "$f3"+                               , "$f30"+                               , "$f31"+                               , "$f4"+                               , "$f5"+                               , "$f6"+                               , "$f7"+                               , "$f8"+                               , "$f9"+                               ])+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet False [ ".data" , ".kdata" , ".ktext" , ".text" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ ".align"+                               , ".ascii"+                               , ".asciiz"+                               , ".byte"+                               , ".double"+                               , ".extern"+                               , ".float"+                               , ".globl"+                               , ".half"+                               , ".sdata"+                               , ".set"+                               , ".space"+                               , ".word"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*BEGIN.*$"+                              , reCompiled = Just (compileRegex True "#\\s*BEGIN.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*END.*$"+                              , reCompiled = Just (compileRegex True "#\\s*END.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#.*$"+                              , reCompiled = Just (compileRegex True "#.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\w_\\.]+:"+                              , reCompiled = Just (compileRegex True "[\\w_\\.]+:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MIPS Assembler" , "string" ) ]+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "string"+          , Context+              { cName = "string"+              , cSyntax = "MIPS Assembler"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Dominik Haumann (dhdev@gmx.de)"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions = [ "*.s" ]+  , sStartingContext = "normal"+  }
+ src/Skylighting/Syntax/Modelines.hs view
@@ -0,0 +1,566 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Modelines (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Modelines"+  , sFilename = "modelines.xml"+  , sShortname = "Modelines"+  , sContexts =+      fromList+        [ ( "Booleans"+          , Context+              { cName = "Booleans"+              , cSyntax = "Modelines"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,./;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "1" , "on" , "true" ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,./;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "0" , "false" , "off" ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = LineContinue+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Integrals"+          , Context+              { cName = "Integrals"+              , cSyntax = "Modelines"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = LineContinue+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Modeline"+          , Context+              { cName = "Modeline"+              , cSyntax = "Modelines"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,./;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "auto-brackets"+                               , "automatic-spell-checking"+                               , "backspace-indents"+                               , "block-selection"+                               , "bom"+                               , "bookmark-sorting"+                               , "byte-order-marker"+                               , "dynamic-word-wrap"+                               , "folding-markers"+                               , "folding-preview"+                               , "icon-border"+                               , "indent-pasted-text"+                               , "keep-extra-spaces"+                               , "line-numbers"+                               , "newline-at-eof"+                               , "overwrite-mode"+                               , "persistent-selection"+                               , "replace-tabs"+                               , "replace-tabs-save"+                               , "replace-trailing-space-save"+                               , "scrollbar-minimap"+                               , "scrollbar-preview"+                               , "show-tabs"+                               , "show-trailing-spaces"+                               , "smart-home"+                               , "space-indent"+                               , "tab-indents"+                               , "word-wrap"+                               , "wrap-cursor"+                               ])+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Modelines" , "Booleans" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,./;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "auto-center-lines"+                               , "font-size"+                               , "indent-mode"+                               , "indent-width"+                               , "tab-width"+                               , "undo-steps"+                               , "word-wrap-column"+                               ])+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Modelines" , "Integrals" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,./;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "background-color"+                               , "bracket-highlight-color"+                               , "current-line-color"+                               , "default-dictionary"+                               , "encoding"+                               , "end-of-line"+                               , "eol"+                               , "font"+                               , "hl"+                               , "icon-bar-color"+                               , "mode"+                               , "scheme"+                               , "selection-color"+                               , "syntax"+                               , "word-wrap-marker-color"+                               ])+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Modelines" , "Strings" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,./;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "remove-trailing-spaces" ])+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Modelines" , "RemoveSpaces" ) ]+                      }+                  , Rule+                      { rMatcher = LineContinue+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Modelines"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,./;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "kate:" ])+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Modelines" , "Modeline" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "kate-(mimetype|wildcard)\\(.*\\):"+                              , reCompiled =+                                  Just (compileRegex True "kate-(mimetype|wildcard)\\(.*\\):")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AnnotationTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Modelines" , "Modeline" ) ]+                      }+                  , Rule+                      { rMatcher = LineContinue+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RemoveSpaces"+          , Context+              { cName = "RemoveSpaces"+              , cSyntax = "Modelines"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,./;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "*"+                               , "+"+                               , "-"+                               , "0"+                               , "1"+                               , "2"+                               , "all"+                               , "mod"+                               , "modified"+                               , "none"+                               ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = LineContinue+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Strings"+          , Context+              { cName = "Strings"+              , cSyntax = "Modelines"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^; ]"+                              , reCompiled = Just (compileRegex True "[^; ]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = CommentVarTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Alex Turbov (i.zaufi@gmail.com)"+  , sVersion = "3"+  , sLicense = "LGPL"+  , sExtensions = []+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Modula2.hs view
@@ -0,0 +1,427 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Modula2 (syntax) where++import Skylighting.Types+import Data.Map+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Modula-2"+  , sFilename = "modula-2.xml"+  , sShortname = "Modula2"+  , sContexts =+      fromList+        [ ( "Comment2"+          , Context+              { cName = "Comment2"+              , cSyntax = "Modula-2"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' ')'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment3"+          , Context+              { cName = "Comment3"+              , cSyntax = "Modula-2"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Modula-2"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ABS"+                               , "AND"+                               , "ARRAY"+                               , "ASM"+                               , "BEGIN"+                               , "BITSET"+                               , "BY"+                               , "CAP"+                               , "CASE"+                               , "CHR"+                               , "CONST"+                               , "DEC"+                               , "DEFINITION"+                               , "DIV"+                               , "DO"+                               , "ELSE"+                               , "ELSIF"+                               , "END"+                               , "EXCL"+                               , "EXIT"+                               , "EXPORT"+                               , "FALSE"+                               , "FOR"+                               , "FOREIGN"+                               , "FROM"+                               , "HALT"+                               , "HIGH"+                               , "IF"+                               , "IMPLEMENTATION"+                               , "IMPORT"+                               , "IN"+                               , "INC"+                               , "INCL"+                               , "IOTRANSFER"+                               , "LOOP"+                               , "MAX"+                               , "MIN"+                               , "MOD"+                               , "MODULE"+                               , "NEWPROCESS"+                               , "NIL"+                               , "NOT"+                               , "ODD"+                               , "OF"+                               , "OR"+                               , "ORD"+                               , "PROC"+                               , "PROCEDURE"+                               , "QUALIFIED"+                               , "RECORD"+                               , "REPEAT"+                               , "RETURN"+                               , "SET"+                               , "THEN"+                               , "TO"+                               , "TRANSFER"+                               , "TRUE"+                               , "TRUNC"+                               , "TYPE"+                               , "UNTIL"+                               , "VAL"+                               , "VAR"+                               , "WHILE"+                               , "WITH"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ALLOCATE"+                               , "ASSEMBLER"+                               , "Accessible"+                               , "Append"+                               , "Assign"+                               , "CAPS"+                               , "Close"+                               , "Concat"+                               , "Copy"+                               , "DEALLOCATE"+                               , "Delete"+                               , "Done"+                               , "EOF"+                               , "EmptyString"+                               , "Erase"+                               , "GetArgs"+                               , "GetCard"+                               , "GetChar"+                               , "GetEnv"+                               , "GetInt"+                               , "GetLongReal"+                               , "GetReal"+                               , "GetString"+                               , "Insert"+                               , "Length"+                               , "Open"+                               , "OpenInput"+                               , "OpenOutput"+                               , "PutBf"+                               , "PutCard"+                               , "PutChar"+                               , "PutInt"+                               , "PutLn"+                               , "PutLongReal"+                               , "PutReal"+                               , "PutString"+                               , "Read"+                               , "ReadCard"+                               , "ReadInt"+                               , "ReadLongReal"+                               , "ReadReal"+                               , "ReadString"+                               , "ResetClock"+                               , "SIZE"+                               , "StrEq"+                               , "SystemTime"+                               , "UserTime"+                               , "Write"+                               , "WriteBf"+                               , "WriteCard"+                               , "WriteInt"+                               , "WriteLn"+                               , "WriteLongReal"+                               , "WriteReal"+                               , "WriteString"+                               , "compare"+                               , "pos"+                               ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ADDRESS"+                               , "ADR"+                               , "BOOLEAN"+                               , "CARDINAL"+                               , "CHAR"+                               , "File"+                               , "INTEGER"+                               , "LONGINT"+                               , "LONGREAL"+                               , "POINTER"+                               , "REAL"+                               , "SHORTCARD"+                               , "SHORTINT"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Modula-2" , "String1" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Modula-2" , "String2" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "(*$"+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Modula-2" , "Prep1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '(' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Modula-2" , "Comment2" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Prep1"+          , Context+              { cName = "Prep1"+              , cSyntax = "Modula-2"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "$*)"+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Modula-2" , "Prep1" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String1"+          , Context+              { cName = "String1"+              , cSyntax = "Modula-2"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String2"+          , Context+              { cName = "String2"+              , cSyntax = "Modula-2"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = ""+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.mod" , "*.def" , "*.mi" , "*.md" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Modula3.hs view
@@ -0,0 +1,665 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Modula3 (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Modula-3"+  , sFilename = "modula-3.xml"+  , sShortname = "Modula3"+  , sContexts =+      fromList+        [ ( "Comment2"+          , Context+              { cName = "Comment2"+              , cSyntax = "Modula-3"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '(' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Modula-3" , "Comment2" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' ')'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Modula-3"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "PROCEDURE[\\s].*\\("+                              , reCompiled = Just (compileRegex True "PROCEDURE[\\s].*\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "END\\s*[A-Za-z][A-Za-z0-9_]*\\;"+                              , reCompiled =+                                  Just (compileRegex True "END\\s*[A-Za-z][A-Za-z0-9_]*\\;")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b(RECORD|OBJECT|TRY|WHILE|FOR|REPEAT|LOOP|IF|CASE|WITH)\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\b(RECORD|OBJECT|TRY|WHILE|FOR|REPEAT|LOOP|IF|CASE|WITH)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(END;|END)\\b"+                              , reCompiled = Just (compileRegex True "\\b(END;|END)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ANY"+                               , "ARRAY"+                               , "AS"+                               , "BEGIN"+                               , "BITS"+                               , "BRANDED"+                               , "BY"+                               , "CASE"+                               , "CONST"+                               , "DO"+                               , "ELSE"+                               , "ELSIF"+                               , "END"+                               , "EVAL"+                               , "EXCEPT"+                               , "EXCEPTION"+                               , "EXIT"+                               , "EXPORTS"+                               , "FINALLY"+                               , "FOR"+                               , "FROM"+                               , "GENERIC"+                               , "IF"+                               , "IMPORT"+                               , "INTERFACE"+                               , "LOCK"+                               , "LOOP"+                               , "METHODS"+                               , "MODULE"+                               , "OBJECT"+                               , "OF"+                               , "OVERRIDES"+                               , "PROCEDURE"+                               , "RAISE"+                               , "RAISES"+                               , "READONLY"+                               , "RECORD"+                               , "REF"+                               , "REPEAT"+                               , "RETURN"+                               , "REVEAL"+                               , "ROOT"+                               , "SET"+                               , "THEN"+                               , "TO"+                               , "TRY"+                               , "TYPE"+                               , "TYPECASE"+                               , "UNSAFE"+                               , "UNTIL"+                               , "UNTRACED"+                               , "VALUE"+                               , "VAR"+                               , "WHILE"+                               , "WITH"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "#"+                               , "&"+                               , "("+                               , ")"+                               , "*"+                               , "+"+                               , ","+                               , "-"+                               , "."+                               , ".."+                               , "/"+                               , ":"+                               , ":="+                               , ";"+                               , "<"+                               , "<:"+                               , "<="+                               , "="+                               , "=>"+                               , ">"+                               , ">="+                               , "AND"+                               , "DIV"+                               , "IN"+                               , "MOD"+                               , "NOT"+                               , "OR"+                               , "["+                               , "]"+                               , "^"+                               , "{"+                               , "|"+                               , "}"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ADDRESS"+                               , "BOOLEAN"+                               , "CARDINAL"+                               , "CHAR"+                               , "EXTENDED"+                               , "INTEGER"+                               , "LONGREAL"+                               , "MUTEX"+                               , "NULL"+                               , "REAL"+                               , "REFANY"+                               , "T"+                               , "TEXT"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "FALSE" , "NIL" , "TRUE" ])+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ABS"+                               , "ADR"+                               , "ADRSIZE"+                               , "BITSIZE"+                               , "BYTESIZE"+                               , "CEILING"+                               , "DEC"+                               , "DISPOSE"+                               , "FIRST"+                               , "FLOAT"+                               , "FLOOR"+                               , "INC"+                               , "ISTYPE"+                               , "LAST"+                               , "LOOPHOLE"+                               , "MAX"+                               , "MIN"+                               , "NARROW"+                               , "NEW"+                               , "NUMBER"+                               , "ORD"+                               , "ROUND"+                               , "SUBARRAY"+                               , "TRUNC"+                               , "TYPECODE"+                               , "VAL"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Env"+                               , "Env.Count"+                               , "Env.Get"+                               , "Env.GetNth"+                               , "Fmt"+                               , "Fmt.Bool"+                               , "Fmt.Char"+                               , "Fmt.Extended"+                               , "Fmt.F"+                               , "Fmt.FN"+                               , "Fmt.Int"+                               , "Fmt.LongReal"+                               , "Fmt.Pad"+                               , "Fmt.Real"+                               , "Fmt.Unsigned"+                               , "IO"+                               , "IO.EOF"+                               , "IO.GetChar"+                               , "IO.GetInt"+                               , "IO.GetLine"+                               , "IO.GetReal"+                               , "IO.GetWideChar"+                               , "IO.OpenRead"+                               , "IO.OpenWrite"+                               , "IO.Put"+                               , "IO.PutChar"+                               , "IO.PutInt"+                               , "IO.PutReal"+                               , "IO.PutWideChar"+                               , "Lex"+                               , "Lex.Bool"+                               , "Lex.Extended"+                               , "Lex.Int"+                               , "Lex.LongReal"+                               , "Lex.Match"+                               , "Lex.Real"+                               , "Lex.Scan"+                               , "Lex.Skip"+                               , "Lex.Unsigned"+                               , "Params"+                               , "Params.Count"+                               , "Params.Get"+                               , "Rd"+                               , "Rd.CharsReady"+                               , "Rd.Close"+                               , "Rd.Closed"+                               , "Rd.EOF"+                               , "Rd.GetChar"+                               , "Rd.GetLine"+                               , "Rd.GetSub"+                               , "Rd.GetSubLine"+                               , "Rd.GetText"+                               , "Rd.GetWideChar"+                               , "Rd.GetWideLine"+                               , "Rd.GetWideSub"+                               , "Rd.GetWideSubLine"+                               , "Rd.GetWideText"+                               , "Rd.Index"+                               , "Rd.Intermittend"+                               , "Rd.Length"+                               , "Rd.Seek"+                               , "Rd.Seekable"+                               , "Rd.UnGetChar"+                               , "Scan"+                               , "Scan.Bool"+                               , "Scan.Extended"+                               , "Scan.Int"+                               , "Scan.LongReal"+                               , "Scan.Real"+                               , "Scan.Unsigned"+                               , "Text"+                               , "Text.Cat"+                               , "Text.Compare"+                               , "Text.Empty"+                               , "Text.Equal"+                               , "Text.FindChar"+                               , "Text.FindCharR"+                               , "Text.FindWideChar"+                               , "Text.FindWideCharR"+                               , "Text.FromChars"+                               , "Text.FromWideChars"+                               , "Text.GetChar"+                               , "Text.GetWideChar"+                               , "Text.HasWideChar"+                               , "Text.Hash"+                               , "Text.Length"+                               , "Text.SetChars"+                               , "Text.SetWideChars"+                               , "Text.Sub"+                               , "Wr"+                               , "Wr.Buffered"+                               , "Wr.Close"+                               , "Wr.Closed"+                               , "Wr.Flush"+                               , "Wr.Index"+                               , "Wr.Length"+                               , "Wr.PutChar"+                               , "Wr.PutString"+                               , "Wr.PutText"+                               , "Wr.PutWideChar"+                               , "Wr.PutWideString"+                               , "Wr.PutWideText"+                               , "Wr.Seek"+                               , "Wr.Seekable"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b[\\+|\\-]{0,1}[0-9]{1,}\\.[0-9]{1,}([E|e|D|d|X|x][\\+|\\-]{0,1}[0-9]{1,}){0,1}\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\b[\\+|\\-]{0,1}[0-9]{1,}\\.[0-9]{1,}([E|e|D|d|X|x][\\+|\\-]{0,1}[0-9]{1,}){0,1}\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b([\\+|\\-]{0,1}[0-9]{1,}|([2-9]|1[0-6])\\_[0-9A-Fa-f]{1,})\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\b([\\+|\\-]{0,1}[0-9]{1,}|([2-9]|1[0-6])\\_[0-9A-Fa-f]{1,})\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Modula-3" , "String1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\'(.|\\\\[ntrf\\\\'\"]|\\\\[0-7]{3})\\'"+                              , reCompiled =+                                  Just+                                    (compileRegex True "\\'(.|\\\\[ntrf\\\\'\"]|\\\\[0-7]{3})\\'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '<' '*'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Modula-3" , "Prep1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '(' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Modula-3" , "Comment2" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Prep1"+          , Context+              { cName = "Prep1"+              , cSyntax = "Modula-3"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '>'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String1"+          , Context+              { cName = "String1"+              , cSyntax = "Modula-3"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = ""+  , sVersion = "1.01"+  , sLicense = "LGPL"+  , sExtensions = [ "*.m3" , "*.i3" , "*.ig" , "*.mg" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Monobasic.hs view
@@ -0,0 +1,987 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Monobasic (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "MonoBasic"+  , sFilename = "monobasic.xml"+  , sShortname = "Monobasic"+  , sContexts =+      fromList+        [ ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "MonoBasic"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "MonoBasic"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "AddHandler"+                               , "And"+                               , "AndAlso"+                               , "As"+                               , "ByRef"+                               , "ByVal"+                               , "Call"+                               , "Catch"+                               , "Const"+                               , "Declare"+                               , "Default"+                               , "Delegate"+                               , "Dim"+                               , "Else"+                               , "Error"+                               , "Event"+                               , "Explicit"+                               , "False"+                               , "Finaly"+                               , "Friend"+                               , "Goto"+                               , "Imports"+                               , "Inherits"+                               , "Me"+                               , "MustInherit"+                               , "MustOverride"+                               , "MyBase"+                               , "MyClass"+                               , "New"+                               , "Not"+                               , "Nothing"+                               , "NotInheritable"+                               , "NotOverridable"+                               , "On"+                               , "Option"+                               , "Optional"+                               , "Or"+                               , "OrElse"+                               , "Overloads"+                               , "Overrides"+                               , "ParamArray"+                               , "Private"+                               , "Protected"+                               , "Public"+                               , "RaiseEvent"+                               , "ReadOnly"+                               , "Redim"+                               , "Resume"+                               , "Return"+                               , "Shadows"+                               , "Shared"+                               , "Step"+                               , "Strict"+                               , "Then"+                               , "Throw"+                               , "To"+                               , "True"+                               , "When"+                               , "WithEvents"+                               , "WriteOnly"+                               , "Xor"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "Boolean"+                               , "Byte"+                               , "Char"+                               , "Date"+                               , "DateTime"+                               , "Decimal"+                               , "Double"+                               , "Exception"+                               , "Guid"+                               , "Int16"+                               , "Int32"+                               , "Int64"+                               , "Integer"+                               , "IntPtr"+                               , "Long"+                               , "Object"+                               , "ParamArray"+                               , "Single"+                               , "String"+                               , "TimeSpan"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MonoBasic" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "MonoBasic" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(Namespace)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(Namespace)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "End.Namespace.*$"+                              , reCompiled = Just (compileRegex False "End.Namespace.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(Module)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(Module)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "End.Module.*$"+                              , reCompiled = Just (compileRegex False "End.Module.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(Class)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(Class)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "End.Class.*$"+                              , reCompiled = Just (compileRegex False "End.Class.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(Interface)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(Interface)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "End.Interface.*$"+                              , reCompiled = Just (compileRegex False "End.Interface.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(Structure)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(Structure)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "End.Structure.*$"+                              , reCompiled = Just (compileRegex False "End.Structure.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(Enum)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(Enum)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "End.Enum.*$"+                              , reCompiled = Just (compileRegex False "End.Enum.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(Property)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(Property)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "End.Property.*$"+                              , reCompiled = Just (compileRegex False "End.Property.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(Get)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(Get)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "End.Get.*$"+                              , reCompiled = Just (compileRegex False "End.Get.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(Set)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(Set)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "End.Set.*$"+                              , reCompiled = Just (compileRegex False "End.Set.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(Sub)([.\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(Sub)([.\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "End.Sub.*$"+                              , reCompiled = Just (compileRegex False "End.Sub.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "Exit.Sub.*$"+                              , reCompiled = Just (compileRegex False "Exit.Sub.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(Function)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(Function)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "End.Function.*$"+                              , reCompiled = Just (compileRegex False "End.Function.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "Exit.Function.*$"+                              , reCompiled = Just (compileRegex False "Exit.Function.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(Try)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(Try)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "End.Try.*$"+                              , reCompiled = Just (compileRegex False "End.Try.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(If)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(If)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "End.If.*$"+                              , reCompiled = Just (compileRegex False "End.If.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "Select.Case.*$"+                              , reCompiled = Just (compileRegex False "Select.Case.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "End.Select.*$"+                              , reCompiled = Just (compileRegex False "End.Select.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(For)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(For)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(Next)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(Next)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(Do)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(Do)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(Loop)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(Loop)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(While)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(While)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "End.While.*$"+                              , reCompiled = Just (compileRegex False "End.While.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "Exit.While.*$"+                              , reCompiled = Just (compileRegex False "Exit.While.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#Region.*$"+                              , reCompiled = Just (compileRegex False "#Region.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#End.Region.*$"+                              , reCompiled = Just (compileRegex False "#End.Region.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#If.*$"+                              , reCompiled = Just (compileRegex False "#If.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#End.If.*$"+                              , reCompiled = Just (compileRegex False "#End.If.*$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "MonoBasic"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Davide Bettio (davide.bettio@kdemail.net)"+  , sVersion = "2"+  , sLicense = "GPL"+  , sExtensions = [ "*.vb" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Nasm.hs view
@@ -0,0 +1,1156 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Nasm (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Intel x86 (NASM)"+  , sFilename = "nasm.xml"+  , sShortname = "Nasm"+  , sContexts =+      fromList+        [ ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "Intel x86 (NASM)"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Intel x86 (NASM)"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "ah"+                               , "al"+                               , "ax"+                               , "bh"+                               , "bl"+                               , "bp"+                               , "bx"+                               , "ch"+                               , "cl"+                               , "cr0"+                               , "cr2"+                               , "cr3"+                               , "cr4"+                               , "cs"+                               , "cx"+                               , "dh"+                               , "di"+                               , "dl"+                               , "dr0"+                               , "dr1"+                               , "dr2"+                               , "dr3"+                               , "dr6"+                               , "dr7"+                               , "ds"+                               , "dx"+                               , "eax"+                               , "ebp"+                               , "ebx"+                               , "ecx"+                               , "edi"+                               , "edx"+                               , "es"+                               , "esi"+                               , "esp"+                               , "fs"+                               , "gs"+                               , "mm0"+                               , "mm1"+                               , "mm2"+                               , "mm3"+                               , "mm4"+                               , "mm5"+                               , "mm6"+                               , "mm7"+                               , "si"+                               , "sp"+                               , "ss"+                               , "st"+                               , "xmm0"+                               , "xmm1"+                               , "xmm2"+                               , "xmm3"+                               , "xmm4"+                               , "xmm5"+                               , "xmm6"+                               , "xmm7"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "byte"+                               , "db"+                               , "dd"+                               , "dq"+                               , "dt"+                               , "dw"+                               , "dword"+                               , "equ"+                               , "incbin"+                               , "ptr"+                               , "qword"+                               , "resb"+                               , "resd"+                               , "resq"+                               , "rest"+                               , "resw"+                               , "short"+                               , "times"+                               , "word"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "aaa"+                               , "aad"+                               , "aam"+                               , "aas"+                               , "adc"+                               , "add"+                               , "addpd"+                               , "addps"+                               , "addsd"+                               , "addss"+                               , "addsubpd"+                               , "addsubps"+                               , "and"+                               , "andnpd"+                               , "andnps"+                               , "andpd"+                               , "andps"+                               , "arpl"+                               , "bound"+                               , "bsf"+                               , "bsr"+                               , "bswap"+                               , "bt"+                               , "btc"+                               , "btr"+                               , "bts"+                               , "call"+                               , "cbw"+                               , "cdq"+                               , "cdqe"+                               , "clc"+                               , "cld"+                               , "clflush"+                               , "clgi"+                               , "cli"+                               , "clts"+                               , "cmc"+                               , "cmova"+                               , "cmovae"+                               , "cmovb"+                               , "cmovbe"+                               , "cmovc"+                               , "cmove"+                               , "cmovg"+                               , "cmovge"+                               , "cmovl"+                               , "cmovle"+                               , "cmovna"+                               , "cmovnae"+                               , "cmovnb"+                               , "cmovnbe"+                               , "cmovnc"+                               , "cmovne"+                               , "cmovng"+                               , "cmovnge"+                               , "cmovnl"+                               , "cmovnle"+                               , "cmovno"+                               , "cmovnp"+                               , "cmovns"+                               , "cmovnz"+                               , "cmovo"+                               , "cmovp"+                               , "cmovpe"+                               , "cmovpo"+                               , "cmovs"+                               , "cmovz"+                               , "cmp"+                               , "cmpeqpd"+                               , "cmpeqps"+                               , "cmpeqsd"+                               , "cmpeqss"+                               , "cmplepd"+                               , "cmpleps"+                               , "cmplesd"+                               , "cmpless"+                               , "cmpltpd"+                               , "cmpltps"+                               , "cmpltsd"+                               , "cmpltss"+                               , "cmpneqpd"+                               , "cmpneqps"+                               , "cmpneqsd"+                               , "cmpneqss"+                               , "cmpnlepd"+                               , "cmpnleps"+                               , "cmpnlesd"+                               , "cmpnless"+                               , "cmpnltpd"+                               , "cmpnltps"+                               , "cmpnltsd"+                               , "cmpnltss"+                               , "cmpordpd"+                               , "cmpordps"+                               , "cmpordsd"+                               , "cmpordss"+                               , "cmppd"+                               , "cmpps"+                               , "cmps"+                               , "cmpsb"+                               , "cmpsd"+                               , "cmpss"+                               , "cmpsw"+                               , "cmpunordpd"+                               , "cmpunordps"+                               , "cmpunordsd"+                               , "cmpunordss"+                               , "cmpxchg"+                               , "cmpxchg16b"+                               , "cmpxchg486"+                               , "cmpxchg8b"+                               , "comisd"+                               , "comiss"+                               , "cpuid"+                               , "cqo"+                               , "cvtdq2pd"+                               , "cvtdq2ps"+                               , "cvtpd2dq"+                               , "cvtpd2pi"+                               , "cvtpd2ps"+                               , "cvtpi2pd"+                               , "cvtpi2ps"+                               , "cvtps2dq"+                               , "cvtps2pd"+                               , "cvtps2pi"+                               , "cvtsd2si"+                               , "cvtsd2ss"+                               , "cvtsi2sd"+                               , "cvtsi2ss"+                               , "cvtss2sd"+                               , "cvtss2si"+                               , "cvttpd2dq"+                               , "cvttpd2pi"+                               , "cvttps2dq"+                               , "cvttps2pi"+                               , "cvttsd2si"+                               , "cvttss2si"+                               , "cwd"+                               , "cwde"+                               , "daa"+                               , "das"+                               , "dec"+                               , "div"+                               , "divpd"+                               , "divps"+                               , "divsd"+                               , "divss"+                               , "emms"+                               , "enter"+                               , "f2xm1"+                               , "fabs"+                               , "fadd"+                               , "faddp"+                               , "fbld"+                               , "fbstp"+                               , "fchs"+                               , "fclex"+                               , "fcmovb"+                               , "fcmovbe"+                               , "fcmove"+                               , "fcmovnb"+                               , "fcmovnbe"+                               , "fcmovne"+                               , "fcmovnu"+                               , "fcmovu"+                               , "fcom"+                               , "fcomi"+                               , "fcomip"+                               , "fcomp"+                               , "fcompp"+                               , "fcos"+                               , "fdecstp"+                               , "fdisi"+                               , "fdiv"+                               , "fdivp"+                               , "fdivr"+                               , "fdivrp"+                               , "femms"+                               , "feni"+                               , "ffree"+                               , "ffreep"+                               , "fiadd"+                               , "ficom"+                               , "ficomp"+                               , "fidiv"+                               , "fidivr"+                               , "fild"+                               , "fimul"+                               , "fincstp"+                               , "finit"+                               , "fist"+                               , "fistp"+                               , "fisttp"+                               , "fisub"+                               , "fisubr"+                               , "fld"+                               , "fld1"+                               , "fldcw"+                               , "fldenv"+                               , "fldl2e"+                               , "fldl2t"+                               , "fldlg2"+                               , "fldln2"+                               , "fldpi"+                               , "fldz"+                               , "fmul"+                               , "fmulp"+                               , "fnclex"+                               , "fndisi"+                               , "fneni"+                               , "fninit"+                               , "fnop"+                               , "fnsave"+                               , "fnstcw"+                               , "fnstenv"+                               , "fnstsw"+                               , "fnwait"+                               , "fpatan"+                               , "fprem"+                               , "fprem1"+                               , "fptan"+                               , "frndint"+                               , "frstor"+                               , "fsave"+                               , "fscale"+                               , "fsetpm"+                               , "fsin"+                               , "fsincos"+                               , "fsqrt"+                               , "fst"+                               , "fstcw"+                               , "fstenv"+                               , "fstp"+                               , "fstsw"+                               , "fsub"+                               , "fsubp"+                               , "fsubr"+                               , "fsubrp"+                               , "ftst"+                               , "fucom"+                               , "fucomi"+                               , "fucomip"+                               , "fucomp"+                               , "fucompp"+                               , "fwait"+                               , "fxam"+                               , "fxch"+                               , "fxrstor"+                               , "fxsave"+                               , "fxtract"+                               , "fyl2x"+                               , "fyl2xp1"+                               , "haddpd"+                               , "haddps"+                               , "hlt"+                               , "hsubpd"+                               , "hsubps"+                               , "ibts"+                               , "idiv"+                               , "imul"+                               , "in"+                               , "inc"+                               , "ins"+                               , "insb"+                               , "insd"+                               , "insw"+                               , "int"+                               , "int1"+                               , "int3"+                               , "into"+                               , "invd"+                               , "invlpg"+                               , "invlpga"+                               , "iret"+                               , "iretd"+                               , "iretq"+                               , "iretw"+                               , "ja"+                               , "jae"+                               , "jb"+                               , "jbe"+                               , "jc"+                               , "jcxz"+                               , "je"+                               , "jecxz"+                               , "jg"+                               , "jge"+                               , "jl"+                               , "jle"+                               , "jmp"+                               , "jna"+                               , "jnae"+                               , "jnb"+                               , "jnbe"+                               , "jnc"+                               , "jne"+                               , "jng"+                               , "jnge"+                               , "jnl"+                               , "jnle"+                               , "jno"+                               , "jnp"+                               , "jns"+                               , "jnz"+                               , "jo"+                               , "jp"+                               , "jpe"+                               , "jpo"+                               , "jrcxz"+                               , "js"+                               , "jz"+                               , "lahf"+                               , "lar"+                               , "lddqu"+                               , "ldmxcsr"+                               , "lds"+                               , "lea"+                               , "leave"+                               , "les"+                               , "lfence"+                               , "lfs"+                               , "lgdt"+                               , "lgs"+                               , "lidt"+                               , "lldt"+                               , "lmsw"+                               , "loadall"+                               , "loadall286"+                               , "lods"+                               , "lodsb"+                               , "lodsd"+                               , "lodsq"+                               , "lodsw"+                               , "loop"+                               , "loope"+                               , "loopne"+                               , "loopnz"+                               , "loopz"+                               , "lsl"+                               , "lss"+                               , "ltr"+                               , "maskmovdqu"+                               , "maskmovq"+                               , "maxpd"+                               , "maxps"+                               , "maxsd"+                               , "maxss"+                               , "mfence"+                               , "minpd"+                               , "minps"+                               , "minsd"+                               , "minss"+                               , "monitor"+                               , "mov"+                               , "movapd"+                               , "movaps"+                               , "movd"+                               , "movddup"+                               , "movdq2q"+                               , "movdqa"+                               , "movdqu"+                               , "movhlps"+                               , "movhpd"+                               , "movhps"+                               , "movlhps"+                               , "movlpd"+                               , "movlps"+                               , "movmskpd"+                               , "movmskps"+                               , "movntdq"+                               , "movnti"+                               , "movntpd"+                               , "movntps"+                               , "movntq"+                               , "movq"+                               , "movq2dq"+                               , "movs"+                               , "movsb"+                               , "movsd"+                               , "movshdup"+                               , "movsldup"+                               , "movsq"+                               , "movss"+                               , "movsw"+                               , "movsx"+                               , "movsxd"+                               , "movupd"+                               , "movups"+                               , "movzx"+                               , "mul"+                               , "mulpd"+                               , "mulps"+                               , "mulsd"+                               , "mulss"+                               , "mwait"+                               , "neg"+                               , "nop"+                               , "not"+                               , "or"+                               , "orpd"+                               , "orps"+                               , "out"+                               , "outs"+                               , "outsb"+                               , "outsd"+                               , "outsw"+                               , "packssdw"+                               , "packsswb"+                               , "packuswb"+                               , "paddb"+                               , "paddd"+                               , "paddq"+                               , "paddsb"+                               , "paddsw"+                               , "paddusb"+                               , "paddusw"+                               , "paddw"+                               , "pand"+                               , "pandn"+                               , "pause"+                               , "pavgb"+                               , "pavgusb"+                               , "pavgw"+                               , "pcmpeqb"+                               , "pcmpeqd"+                               , "pcmpeqw"+                               , "pcmpgtb"+                               , "pcmpgtd"+                               , "pcmpgtw"+                               , "pdistib"+                               , "pextrw"+                               , "pf2id"+                               , "pf2iw"+                               , "pfacc"+                               , "pfadd"+                               , "pfcmpeq"+                               , "pfcmpge"+                               , "pfcmpgt"+                               , "pfmax"+                               , "pfmin"+                               , "pfmul"+                               , "pfnacc"+                               , "pfpnacc"+                               , "pfrcp"+                               , "pfrcpit1"+                               , "pfrcpit2"+                               , "pfrsqit1"+                               , "pfrsqrt"+                               , "pfsub"+                               , "pfsubr"+                               , "pi2fd"+                               , "pi2fw"+                               , "pinsrw"+                               , "pmachriw"+                               , "pmaddwd"+                               , "pmagw"+                               , "pmaxsw"+                               , "pmaxub"+                               , "pminsw"+                               , "pminub"+                               , "pmovmskb"+                               , "pmulhrw"+                               , "pmulhuw"+                               , "pmulhw"+                               , "pmullw"+                               , "pmuludq"+                               , "pmvgezb"+                               , "pmvlzb"+                               , "pmvnzb"+                               , "pmvzb"+                               , "pop"+                               , "popa"+                               , "popad"+                               , "popaw"+                               , "popf"+                               , "popfd"+                               , "popfq"+                               , "popfw"+                               , "por"+                               , "prefetch"+                               , "prefetchnta"+                               , "prefetcht0"+                               , "prefetcht1"+                               , "prefetcht2"+                               , "prefetchw"+                               , "psadbw"+                               , "pshufd"+                               , "pshufhw"+                               , "pshuflw"+                               , "pshufw"+                               , "pslld"+                               , "pslldq"+                               , "psllq"+                               , "psllw"+                               , "psrad"+                               , "psraw"+                               , "psrld"+                               , "psrldq"+                               , "psrlq"+                               , "psrlw"+                               , "psubb"+                               , "psubd"+                               , "psubq"+                               , "psubsb"+                               , "psubsiw"+                               , "psubsw"+                               , "psubusb"+                               , "psubusw"+                               , "psubw"+                               , "pswapd"+                               , "punpckhbw"+                               , "punpckhdq"+                               , "punpckhqdq"+                               , "punpckhwd"+                               , "punpcklbw"+                               , "punpckldq"+                               , "punpcklqdq"+                               , "punpcklwd"+                               , "push"+                               , "pusha"+                               , "pushad"+                               , "pushaw"+                               , "pushf"+                               , "pushfd"+                               , "pushfq"+                               , "pushfw"+                               , "pxor"+                               , "rcl"+                               , "rcpps"+                               , "rcpss"+                               , "rcr"+                               , "rdmsr"+                               , "rdpmc"+                               , "rdshr"+                               , "rdtsc"+                               , "rdtscp"+                               , "ret"+                               , "retf"+                               , "retn"+                               , "rol"+                               , "ror"+                               , "rsdc"+                               , "rsldt"+                               , "rsm"+                               , "rsqrtps"+                               , "rsqrtss"+                               , "rsts"+                               , "sahf"+                               , "sal"+                               , "salc"+                               , "sar"+                               , "sbb"+                               , "scas"+                               , "scasb"+                               , "scasd"+                               , "scasq"+                               , "scasw"+                               , "seta"+                               , "setae"+                               , "setb"+                               , "setbe"+                               , "setc"+                               , "sete"+                               , "setg"+                               , "setge"+                               , "setl"+                               , "setle"+                               , "setna"+                               , "setnae"+                               , "setnb"+                               , "setnbe"+                               , "setnc"+                               , "setne"+                               , "setng"+                               , "setnge"+                               , "setnl"+                               , "setnle"+                               , "setno"+                               , "setnp"+                               , "setns"+                               , "setnz"+                               , "seto"+                               , "setp"+                               , "setpe"+                               , "setpo"+                               , "sets"+                               , "setz"+                               , "sfence"+                               , "sgdt"+                               , "shl"+                               , "shld"+                               , "shr"+                               , "shrd"+                               , "shufpd"+                               , "shufps"+                               , "sidt"+                               , "skinit"+                               , "sldt"+                               , "smi"+                               , "smint"+                               , "smintold"+                               , "smsw"+                               , "sqrtpd"+                               , "sqrtps"+                               , "sqrtsd"+                               , "sqrtss"+                               , "stc"+                               , "std"+                               , "stgi"+                               , "sti"+                               , "stmxcsr"+                               , "stos"+                               , "stosb"+                               , "stosd"+                               , "stosq"+                               , "stosw"+                               , "str"+                               , "sub"+                               , "subpd"+                               , "subps"+                               , "subsd"+                               , "subss"+                               , "svdc"+                               , "svldt"+                               , "svts"+                               , "swapgs"+                               , "syscall"+                               , "sysenter"+                               , "sysexit"+                               , "sysret"+                               , "test"+                               , "ucomisd"+                               , "ucomiss"+                               , "ud0"+                               , "ud1"+                               , "ud2"+                               , "umov"+                               , "unpckhpd"+                               , "unpckhps"+                               , "unpcklpd"+                               , "unpcklps"+                               , "verr"+                               , "verw"+                               , "vmload"+                               , "vmmcall"+                               , "vmrun"+                               , "vmsave"+                               , "wait"+                               , "wbinvd"+                               , "wrmsr"+                               , "wrshr"+                               , "xadd"+                               , "xbts"+                               , "xchg"+                               , "xlat"+                               , "xlatb"+                               , "xor"+                               , "xorpd"+                               , "xorps"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "___NASM_PATCHLEVEL__"+                               , "__FILE__"+                               , "__LINE__"+                               , "__NASM_MAJOR__"+                               , "__NASM_MINOR__"+                               , "__NASM_SUBMINOR__"+                               , "__NASM_VER__"+                               , "__NASM_VERSION_ID__"+                               , "__SECT__"+                               , "absolute"+                               , "align"+                               , "alignb"+                               , "at"+                               , "bits"+                               , "common"+                               , "endstruc"+                               , "extern"+                               , "global"+                               , "iend"+                               , "istruc"+                               , "org"+                               , "section"+                               , "seg"+                               , "segment"+                               , "strict"+                               , "struc"+                               , "use16"+                               , "use32"+                               , "wrt"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Intel x86 (NASM)" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Intel x86 (NASM)" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "\"'"+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Intel x86 (NASM)" , "String" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*[A-Za-z0-9_.$]+:"+                              , reCompiled = Just (compileRegex True "\\s*[A-Za-z0-9_.$]+:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(cmov|fcmov|j|loop|set)(a|ae|b|be|c|e|g|ge|l|le|na|nae|nb|nbe|nc|ne|ng|nge|nl|nle|no|np|ns|nz|o|p|pe|po|s|z)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(cmov|fcmov|j|loop|set)(a|ae|b|be|c|e|g|ge|l|le|na|nae|nb|nbe|nc|ne|ng|nge|nl|nle|no|np|ns|nz|o|p|pe|po|s|z)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "cpu (pentium|ppro|p2|p3|katmai|p4|willamette|prescott|ia64)*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "cpu (pentium|ppro|p2|p3|katmai|p4|willamette|prescott|ia64)*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(^|[ \\t,]+)((\\$|0x){1}[0-9]+[a-f0-9]*|[0-9]+[a-f0-9]*h)([ \\t,]+|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "(^|[ \\t,]+)((\\$|0x){1}[0-9]+[a-f0-9]*|[0-9]+[a-f0-9]*h)([ \\t,]+|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(^|[ \\t,]+)([0-7]+(q|o)|[01]+b)([ \\t,]+|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False "(^|[ \\t,]+)([0-7]+(q|o)|[01]+b)([ \\t,]+|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Preprocessor"+          , Context+              { cName = "Preprocessor"+              , cSyntax = "Intel x86 (NASM)"+              , cRules = []+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Intel x86 (NASM)"+              , cRules =+                  [ Rule+                      { rMatcher = AnyChar "\"'"+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Nicola Gigante (nicola.gigante@gmail.com)"+  , sVersion = "3"+  , sLicense = "GPLv2+"+  , sExtensions = [ "*.asm" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Noweb.hs view
@@ -0,0 +1,303 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Noweb (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex++syntax :: Syntax+syntax = Syntax+  { sName = "noweb"+  , sFilename = "noweb.xml"+  , sShortname = "Noweb"+  , sContexts =+      fromList+        [ ( "CodeQuote"+          , Context+              { cName = "CodeQuote"+              , cSyntax = "noweb"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '@' ']'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\]\\](?!\\])"+                              , reCompiled = Just (compileRegex True "\\]\\](?!\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "noweb" , "SectionNames" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "C++" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = True+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CodeSection"+          , Context+              { cName = "CodeSection"+              , cSyntax = "noweb"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@$"+                              , reCompiled = Just (compileRegex True "@$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "noweb" , "RawDocumentation" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@(?=[\\s%])"+                              , reCompiled = Just (compileRegex True "@(?=[\\s%])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "noweb" , "RawDocumentation" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<<.*>>=$"+                              , reCompiled = Just (compileRegex True "<<.*>>=$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "noweb" , "RawDocumentation" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "noweb" , "SectionNames" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "C++" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = True+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RawDocumentation"+          , Context+              { cName = "RawDocumentation"+              , cSyntax = "noweb"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<<.*>>=$"+                              , reCompiled = Just (compileRegex True "<<.*>>=$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "noweb" , "CodeSection" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '@' '['+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '[' '['+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "noweb" , "CodeQuote" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "HTML" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = True+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SectionNames"+          , Context+              { cName = "SectionNames"+              , cSyntax = "noweb"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@<<"+                              , reCompiled = Just (compileRegex True "@<<")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<<.*[^@]>>(?!=)"+                              , reCompiled = Just (compileRegex True "<<.*[^@]>>(?!=)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Scott Collins (scc@scottcollins.net)"+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.w" , "*.nw" ]+  , sStartingContext = "RawDocumentation"+  }
+ src/Skylighting/Syntax/Objectivec.hs view
@@ -0,0 +1,603 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Objectivec (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Objective-C"+  , sFilename = "objectivec.xml"+  , sShortname = "Objectivec"+  , sContexts =+      fromList+        [ ( "Default"+          , Context+              { cName = "Default"+              , cSyntax = "Objective-C"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "@class"+                               , "@defs"+                               , "@encode"+                               , "@end"+                               , "@implementation"+                               , "@interface"+                               , "@private"+                               , "@protected"+                               , "@protocol"+                               , "@public"+                               , "@selector"+                               , "break"+                               , "case"+                               , "continue"+                               , "default"+                               , "do"+                               , "else"+                               , "enum"+                               , "extern"+                               , "for"+                               , "goto"+                               , "if"+                               , "return"+                               , "self"+                               , "sizeof"+                               , "struct"+                               , "super"+                               , "switch"+                               , "typedef"+                               , "union"+                               , "while"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "auto"+                               , "char"+                               , "const"+                               , "double"+                               , "float"+                               , "int"+                               , "long"+                               , "register"+                               , "short"+                               , "signed"+                               , "static"+                               , "unsigned"+                               , "void"+                               , "volatile"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren =+                          [ Rule+                              { rMatcher = AnyChar "fF"+                              , rAttribute = FloatTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = True+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren =+                          [ Rule+                              { rMatcher = StringDetect "ULL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LUL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LLU"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "UL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LU"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "U"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "L"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective-C" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective-C" , "SingleLineComment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective-C" , "MultiLineComment" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar ":!%&()+,-/.*<=>?[]|~^;"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#"+                              , reCompiled = Just (compileRegex True "#")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Objective-C" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '@' '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective-C" , "String" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MultiLineComment"+          , Context+              { cName = "MultiLineComment"+              , cSyntax = "Objective-C"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MultiLineCommentPrep"+          , Context+              { cName = "MultiLineCommentPrep"+              , cSyntax = "Objective-C"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Preprocessor"+          , Context+              { cName = "Preprocessor"+              , cSyntax = "Objective-C"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = RangeDetect '"' '"'+                      , rAttribute = ImportTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = RangeDetect '<' '>'+                      , rAttribute = ImportTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "" )+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective-C" , "SingleLineComment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Objective-C" , "MultiLineCommentPrep" ) ]+                      }+                  ]+              , cAttribute = PreprocessorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Objective-C" , "Default" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SingleLineComment"+          , Context+              { cName = "SingleLineComment"+              , cSyntax = "Objective-C"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Objective-C"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = ""+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.m" , "*.h" ]+  , sStartingContext = "Default"+  }
+ src/Skylighting/Syntax/Objectivecpp.hs view
@@ -0,0 +1,1353 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Objectivecpp (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Objective-C++"+  , sFilename = "objectivecpp.xml"+  , sShortname = "Objectivecpp"+  , sContexts =+      fromList+        [ ( "Commentar 1"+          , Context+              { cName = "Commentar 1"+              , cSyntax = "Objective-C++"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Commentar 2"+          , Context+              { cName = "Commentar 2"+              , cSyntax = "Objective-C++"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Default"+          , Context+              { cName = "Default"+              , cSyntax = "Objective-C++"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*if\\s+0"+                              , reCompiled = Just (compileRegex True "#\\s*if\\s+0")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective-C++" , "Outscoped" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective-C++" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "//BEGIN"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective-C++" , "Region Marker" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "//END"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective-C++" , "Region Marker" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "@class"+                               , "@defs"+                               , "@encode"+                               , "@end"+                               , "@implementation"+                               , "@interface"+                               , "@private"+                               , "@protected"+                               , "@protocol"+                               , "@public"+                               , "@selector"+                               , "and"+                               , "and_eq"+                               , "asm"+                               , "bad_cast"+                               , "bad_typeid"+                               , "bitand"+                               , "bitor"+                               , "break"+                               , "case"+                               , "catch"+                               , "class"+                               , "compl"+                               , "const_cast"+                               , "continue"+                               , "default"+                               , "delete"+                               , "do"+                               , "dynamic_cast"+                               , "else"+                               , "enum"+                               , "explicit"+                               , "export"+                               , "extern"+                               , "false"+                               , "for"+                               , "friend"+                               , "goto"+                               , "if"+                               , "inline"+                               , "namespace"+                               , "new"+                               , "not"+                               , "not_eq"+                               , "operator"+                               , "or"+                               , "or_eq"+                               , "private"+                               , "protected"+                               , "public"+                               , "qobject_cast"+                               , "reinterpret_cast"+                               , "return"+                               , "self"+                               , "sizeof"+                               , "static_cast"+                               , "struct"+                               , "super"+                               , "switch"+                               , "template"+                               , "this"+                               , "throw"+                               , "true"+                               , "try"+                               , "type_info"+                               , "typedef"+                               , "typeid"+                               , "typename"+                               , "union"+                               , "using"+                               , "virtual"+                               , "while"+                               , "xor"+                               , "xor_eq"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "auto"+                               , "bool"+                               , "char"+                               , "const"+                               , "double"+                               , "float"+                               , "int"+                               , "int16_t"+                               , "int32_t"+                               , "int64_t"+                               , "int8_t"+                               , "long"+                               , "mutable"+                               , "register"+                               , "short"+                               , "signed"+                               , "static"+                               , "uchar"+                               , "uint"+                               , "uint16_t"+                               , "uint32_t"+                               , "uint64_t"+                               , "uint8_t"+                               , "unsigned"+                               , "void"+                               , "volatile"+                               , "wchar_t"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren =+                          [ Rule+                              { rMatcher = AnyChar "fF"+                              , rAttribute = FloatTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = True+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren =+                          [ Rule+                              { rMatcher = StringDetect "ULL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LUL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LLU"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "UL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LU"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "U"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "L"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective-C++" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Objective-C++" , "SingleLineComment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Objective-C++" , "MultiLineComment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#"+                              , reCompiled = Just (compileRegex True "#")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Objective-C++" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '@' '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective-C++" , "String" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "FALSE"+                               , "K_DCOP"+                               , "Q_ARG"+                               , "Q_ASSERT"+                               , "Q_ASSERT_X"+                               , "Q_CLASSINFO"+                               , "Q_CLEANUP_RESOURCE"+                               , "Q_D"+                               , "Q_DECLARE_FLAGS"+                               , "Q_DECLARE_INTERFACE"+                               , "Q_DECLARE_OPERATORS_FOR_FLAGS"+                               , "Q_DECLARE_PRIVATE"+                               , "Q_DECLARE_PUBLIC"+                               , "Q_DECLARE_SHARED"+                               , "Q_DECLARE_TYPEINFO"+                               , "Q_DISABLE_COPY"+                               , "Q_ENUMS"+                               , "Q_EXPORT"+                               , "Q_FLAGS"+                               , "Q_FOREACH"+                               , "Q_FOREVER"+                               , "Q_GADGET"+                               , "Q_GLOBAL_STATIC"+                               , "Q_GLOBAL_STATIC_WITH_ARGS"+                               , "Q_INIT_RESOURCE"+                               , "Q_INTERFACES"+                               , "Q_INVOKABLE"+                               , "Q_OBJECT"+                               , "Q_OVERRIDE"+                               , "Q_PROPERTY"+                               , "Q_Q"+                               , "Q_RETURN_ARG"+                               , "Q_SCRIPTABLE"+                               , "Q_SETS"+                               , "Q_SIGNALS"+                               , "Q_SLOTS"+                               , "SIGNAL"+                               , "SLOT"+                               , "TRUE"+                               , "connect"+                               , "disconnect"+                               , "emit"+                               , "foreach"+                               , "forever"+                               , "signals"+                               , "slots"+                               ])+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective-C++" , "Commentar 1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective-C++" , "Commentar 2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar ":!%&()+,-/.*<=>?[]{|}~^;"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Define"+          , Context+              { cName = "Define"+              , cSyntax = "Objective-C++"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = PreprocessorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MultiLineComment"+          , Context+              { cName = "MultiLineComment"+              , cSyntax = "Objective-C++"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MultiLineCommentPrep"+          , Context+              { cName = "MultiLineCommentPrep"+              , cSyntax = "Objective-C++"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Outscoped"+          , Context+              { cName = "Outscoped"+              , cSyntax = "Objective-C++"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective-C++" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective-C++" , "Commentar 1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective-C++" , "Commentar 2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*if"+                              , reCompiled = Just (compileRegex True "#\\s*if")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Objective-C++" , "Outscoped intern" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*(endif|else|elif)"+                              , reCompiled = Just (compileRegex True "#\\s*(endif|else|elif)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Outscoped intern"+          , Context+              { cName = "Outscoped intern"+              , cSyntax = "Objective-C++"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective-C++" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective-C++" , "Commentar 1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective-C++" , "Commentar 2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*if"+                              , reCompiled = Just (compileRegex True "#\\s*if")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Objective-C++" , "Outscoped intern" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*endif"+                              , reCompiled = Just (compileRegex True "#\\s*endif")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Preprocessor"+          , Context+              { cName = "Preprocessor"+              , cSyntax = "Objective-C++"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "define.*((?=\\\\))"+                              , reCompiled = Just (compileRegex True "define.*((?=\\\\))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective-C++" , "Define" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "define.*"+                              , reCompiled = Just (compileRegex True "define.*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = RangeDetect '"' '"'+                      , rAttribute = ImportTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = RangeDetect '<' '>'+                      , rAttribute = ImportTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "" )+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective-C++" , "Commentar 1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Objective-C++" , "MultiLineCommentPrep" ) ]+                      }+                  ]+              , cAttribute = PreprocessorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Region Marker"+          , Context+              { cName = "Region Marker"+              , cSyntax = "Objective-C++"+              , cRules = []+              , cAttribute = RegionMarkerTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SingleLineComment"+          , Context+              { cName = "SingleLineComment"+              , cSyntax = "Objective-C++"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Objective-C++"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Gennady Telegin (gepo@lvk.cs.msu.su"+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.mm" , "*.M" , "*.h" ]+  , sStartingContext = "Default"+  }
+ src/Skylighting/Syntax/Ocaml.hs view
@@ -0,0 +1,2223 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Ocaml (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Objective Caml"+  , sFilename = "ocaml.xml"+  , sShortname = "Ocaml"+  , sContexts =+      fromList+        [ ( "Camlp4 Quotation"+          , Context+              { cName = "Camlp4 Quotation"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '>' '>'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '<' '<'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Objective Caml" , "Camlp4 Quotation" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "<:`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*<"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "<:`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*<")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Objective Caml" , "Camlp4 Quotation" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(\\\\|>>|<<)"+                              , reCompiled = Just (compileRegex True "\\\\(\\\\|>>|<<)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\<:`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*<"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\<:`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*<")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Code"+          , Context+              { cName = "Code"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective Caml" , "Nested Code 1" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective Caml" , "Nested Code 2" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "(**)"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "(**"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective Caml" , "Ocamldoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\(\\*\\$(T|Q|R|=)"+                              , reCompiled = Just (compileRegex True "\\(\\*\\$(T|Q|R|=)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective Caml" , "qtest header" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '(' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective Caml" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "#`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*.*$"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "#`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective Caml" , "String" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "'((\\\\[ntbr'\"\\\\]|\\\\[0-9]{3}|\\\\x[0-9A-Fa-f]{2})|[^'])'"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "'((\\\\[ntbr'\"\\\\]|\\\\[0-9]{3}|\\\\x[0-9A-Fa-f]{2})|[^'])'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '<' '<'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Objective Caml" , "Camlp4 Quotation" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "<:`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*<"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "<:`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*<")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Objective Caml" , "Camlp4 Quotation" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "and"+                               , "as"+                               , "asr"+                               , "assert"+                               , "begin"+                               , "class"+                               , "closed"+                               , "constraint"+                               , "do"+                               , "done"+                               , "downto"+                               , "else"+                               , "end"+                               , "exception"+                               , "external"+                               , "false"+                               , "for"+                               , "fun"+                               , "function"+                               , "functor"+                               , "if"+                               , "in"+                               , "include"+                               , "inherit"+                               , "land"+                               , "lazy"+                               , "let"+                               , "lor"+                               , "lsl"+                               , "lsr"+                               , "lxor"+                               , "match"+                               , "method"+                               , "mod"+                               , "module"+                               , "mutable"+                               , "new"+                               , "object"+                               , "of"+                               , "open"+                               , "or"+                               , "parser"+                               , "private"+                               , "rec"+                               , "sig"+                               , "struct"+                               , "then"+                               , "to"+                               , "true"+                               , "try"+                               , "type"+                               , "val"+                               , "virtual"+                               , "when"+                               , "while"+                               , "with"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "declare" , "value" , "where" ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True [ "exit" , "failwith" , "invalid_arg" , "raise" ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "abs"+                               , "abs_float"+                               , "acos"+                               , "asin"+                               , "at_exit"+                               , "atan"+                               , "atan2"+                               , "bool_of_string"+                               , "ceil"+                               , "char_of_int"+                               , "classify_float"+                               , "close_in"+                               , "close_in_noerr"+                               , "close_out"+                               , "close_out_noerr"+                               , "compare"+                               , "cos"+                               , "cosh"+                               , "decr"+                               , "do_at_exit"+                               , "epsilon_float"+                               , "exp"+                               , "float"+                               , "float_of_int"+                               , "float_of_string"+                               , "floor"+                               , "flush"+                               , "flush_all"+                               , "format_of_string"+                               , "frexp"+                               , "fst"+                               , "ignore"+                               , "in_channel_length"+                               , "incr"+                               , "infinity"+                               , "input"+                               , "input_binary_int"+                               , "input_byte"+                               , "input_char"+                               , "input_line"+                               , "input_value"+                               , "int_of_char"+                               , "int_of_float"+                               , "int_of_string"+                               , "ldexp"+                               , "lnot"+                               , "log"+                               , "log10"+                               , "max"+                               , "max_float"+                               , "max_int"+                               , "min"+                               , "min_float"+                               , "min_int"+                               , "mod_float"+                               , "modf"+                               , "nan"+                               , "neg_infinity"+                               , "not"+                               , "open_in"+                               , "open_in_bin"+                               , "open_in_gen"+                               , "open_out"+                               , "open_out_bin"+                               , "open_out_gen"+                               , "out_channel_length"+                               , "output"+                               , "output_binary_int"+                               , "output_byte"+                               , "output_char"+                               , "output_string"+                               , "output_value"+                               , "pos_in"+                               , "pos_out"+                               , "pred"+                               , "prerr_char"+                               , "prerr_endline"+                               , "prerr_float"+                               , "prerr_int"+                               , "prerr_newline"+                               , "prerr_string"+                               , "print_char"+                               , "print_endline"+                               , "print_float"+                               , "print_int"+                               , "print_newline"+                               , "print_string"+                               , "read_float"+                               , "read_int"+                               , "read_line"+                               , "really_input"+                               , "ref"+                               , "seek_in"+                               , "seek_out"+                               , "set_binary_mode_in"+                               , "set_binary_mode_out"+                               , "sin"+                               , "sinh"+                               , "snd"+                               , "sqrt"+                               , "stderr"+                               , "stdin"+                               , "stdout"+                               , "string_of_bool"+                               , "string_of_float"+                               , "string_of_format"+                               , "string_of_int"+                               , "succ"+                               , "tan"+                               , "tanh"+                               , "truncate"+                               , "unsafe_really_input"+                               , "valid_float_lexem"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "array"+                               , "bool"+                               , "char"+                               , "exn"+                               , "format4"+                               , "fpclass"+                               , "in_channel"+                               , "int"+                               , "int32"+                               , "int64"+                               , "lazy_t"+                               , "list"+                               , "nativeint"+                               , "open_flag"+                               , "option"+                               , "out_channel"+                               , "real"+                               , "ref"+                               , "string"+                               , "unit"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Assert_failure"+                               , "Division_by_zero"+                               , "End_of_file"+                               , "Exit"+                               , "Failure"+                               , "Invalid_argument"+                               , "Match_failure"+                               , "Not_found"+                               , "Out_of_memory"+                               , "Stack_overflow"+                               , "Sys_blocked_io"+                               , "Sys_error"+                               , "Undefined_recursive_module"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "FP_infinite"+                               , "FP_nan"+                               , "FP_normal"+                               , "FP_subnormal"+                               , "FP_zero"+                               , "None"+                               , "Open_append"+                               , "Open_binary"+                               , "Open_creat"+                               , "Open_excl"+                               , "Open_nonblock"+                               , "Open_rdonly"+                               , "Open_text"+                               , "Open_trunc"+                               , "Open_wronly"+                               , "Some"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Arg"+                               , "Array"+                               , "ArrayLabels"+                               , "Buffer"+                               , "Callback"+                               , "Char"+                               , "Complex"+                               , "Digest"+                               , "Filename"+                               , "Format"+                               , "Gc"+                               , "Genlex"+                               , "Hashtbl"+                               , "Int32"+                               , "Int64"+                               , "Lazy"+                               , "Lexing"+                               , "List"+                               , "ListLabels"+                               , "Map"+                               , "Marshal"+                               , "MoreLabels"+                               , "Nativeint"+                               , "Oo"+                               , "Parsing"+                               , "Printexc"+                               , "Printf"+                               , "Queue"+                               , "Random"+                               , "Scanf"+                               , "Set"+                               , "Sort"+                               , "Stack"+                               , "StdLabels"+                               , "Stream"+                               , "String"+                               , "StringLabels"+                               , "Sys"+                               , "Weak"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "[a-z\\300-\\326\\330-\\337_][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "[a-z\\300-\\326\\330-\\337_][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "`?[A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "`?[A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-?0[xX][0-9A-Fa-f_]+"+                              , reCompiled = Just (compileRegex True "-?0[xX][0-9A-Fa-f_]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-?0[oO][0-7_]+"+                              , reCompiled = Just (compileRegex True "-?0[oO][0-7_]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-?0[bB][01_]+"+                              , reCompiled = Just (compileRegex True "-?0[bB][01_]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "-?[0-9][0-9_]*(\\.[0-9][0-9_]*([eE][-+]?[0-9][0-9_]*)?|[eE][-+]?[0-9][0-9_]*)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "-?[0-9][0-9_]*(\\.[0-9][0-9_]*([eE][-+]?[0-9][0-9_]*)?|[eE][-+]?[0-9][0-9_]*)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-?[0-9][0-9_]*"+                              , reCompiled = Just (compileRegex True "-?[0-9][0-9_]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Objective Caml" , "Unmatched Closing Brackets" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' ')'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '(' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective Caml" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Objective Caml" , "String in Comment" ) ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Nested Code 1"+          , Context+              { cName = "Nested Code 1"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Objective Caml" , "Code" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = True+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Nested Code 2"+          , Context+              { cName = "Nested Code 2"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Objective Caml" , "Code" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = True+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Nested Ocamldoc"+          , Context+              { cName = "Nested Ocamldoc"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' ')'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Objective Caml" , "Ocamldoc" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = True+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Ocamldoc"+          , Context+              { cName = "Ocamldoc"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' ')'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "(**)"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "(**"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective Caml" , "Ocamldoc" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '(' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective Caml" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Objective Caml" , "String in Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective Caml" , "Ocamldoc Code" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '{' '['+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Objective Caml" , "Ocamldoc Preformatted" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '{' '%'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective Caml" , "Ocamldoc LaTeX" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '{' '^'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Objective Caml" , "Nested Ocamldoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[{]v(\\s|$)"+                              , reCompiled = Just (compileRegex True "[{]v(\\s|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Objective Caml" , "Ocamldoc Verbatim" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[{]b(\\s|$)"+                              , reCompiled = Just (compileRegex True "[{]b(\\s|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective Caml" , "Ocamldoc Bold" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[{]i(\\s|$)"+                              , reCompiled = Just (compileRegex True "[{]i(\\s|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Objective Caml" , "Ocamldoc Italic" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[{]e(\\s|$)"+                              , reCompiled = Just (compileRegex True "[{]e(\\s|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Objective Caml" , "Ocamldoc Emphasised" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "[{][0-9]+(:`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*)?\\s"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "[{][0-9]+(:`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*)?\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Objective Caml" , "Ocamldoc Heading" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "[{][{]:`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*[}]"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "[{][{]:`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*[}]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective Caml" , "Ocamldoc Link" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[{]!([a-z]+:)?"+                              , reCompiled = Just (compileRegex True "[{]!([a-z]+:)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Objective Caml" , "Ocamldoc References" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "[{]`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*(\\s|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "[{]`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*(\\s|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Objective Caml" , "Nested Ocamldoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@see\\s*(<[^>]*>|\"[^\"]*\"|'[^']*')"+                              , reCompiled =+                                  Just (compileRegex True "@see\\s*(<[^>]*>|\"[^\"]*\"|'[^']*')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@(param|raise)\\s*"+                              , reCompiled = Just (compileRegex True "@(param|raise)\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Objective Caml" , "Ocamldoc Identifier" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@(author|deprecated|return|since|version)"+                              , reCompiled =+                                  Just+                                    (compileRegex True "@(author|deprecated|return|since|version)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "@`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "@`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[  ]*-\\s"+                              , reCompiled = Just (compileRegex True "[  ]*-\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Objective Caml" , "Unmatched Closing Brackets" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Ocamldoc Bold"+          , Context+              { cName = "Ocamldoc Bold"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Objective Caml" , "Nested Ocamldoc" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Ocamldoc Code"+          , Context+              { cName = "Ocamldoc Code"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Objective Caml" , "Code" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = True+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Ocamldoc Emphasised"+          , Context+              { cName = "Ocamldoc Emphasised"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Objective Caml" , "Nested Ocamldoc" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Ocamldoc Heading"+          , Context+              { cName = "Ocamldoc Heading"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Objective Caml" , "Nested Ocamldoc" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Ocamldoc Identifier"+          , Context+              { cName = "Ocamldoc Identifier"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*(\\.`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*)*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*(\\.`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*)*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' ')'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Ocamldoc Italic"+          , Context+              { cName = "Ocamldoc Italic"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Objective Caml" , "Nested Ocamldoc" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Ocamldoc LaTeX"+          , Context+              { cName = "Ocamldoc LaTeX"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '%' '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "LaTeX" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Ocamldoc Link"+          , Context+              { cName = "Ocamldoc Link"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Objective Caml" , "Nested Ocamldoc" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Ocamldoc Preformatted"+          , Context+              { cName = "Ocamldoc Preformatted"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars ']' '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Objective Caml" , "Code" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = True+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Ocamldoc References"+          , Context+              { cName = "Ocamldoc References"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' ')'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*(\\.`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*)*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*(\\.`?[a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\377][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*)*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Ocamldoc Verbatim"+          , Context+              { cName = "Ocamldoc Verbatim"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars 'v' '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\\\[ntbr'\"\\\\]|\\\\[0-9]{3}|\\\\x[0-9A-Fa-f]{2})"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(\\\\[ntbr'\"\\\\]|\\\\[0-9]{3}|\\\\x[0-9A-Fa-f]{2})")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\$"+                              , reCompiled = Just (compileRegex True "\\\\$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String in Comment"+          , Context+              { cName = "String in Comment"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Objective Caml" , "String" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Unmatched Closing Brackets"+          , Context+              { cName = "Unmatched Closing Brackets"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' ')'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars 'v' '}'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars ']' '}'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '%' '}'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "qtest"+          , Context+              { cName = "qtest"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Objective Caml" , "Code" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = True+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "qtest header"+          , Context+              { cName = "qtest header"+              , cSyntax = "Objective Caml"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "as" , "forall" , "in" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '&'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Objective Caml" , "qtest param" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "[a-z\\300-\\326\\330-\\337_][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "[a-z\\300-\\326\\330-\\337_][a-z\\300-\\326\\330-\\337A-Z\\340-\\366\\370-\\3770-9_']*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Objective Caml" , "qtest" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "qtest param"+          , Context+              { cName = "qtest param"+              , cSyntax = "Objective Caml"+              , cRules = []+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Objective Caml" , "qtest" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor =+      "Glyn Webster (glynwebster@orcon.net.nz) and Vincent Hugot (vincent.hugot@gmail.com)"+  , sVersion = "3"+  , sLicense = "LGPL"+  , sExtensions = [ "*.ml" , "*.mli" ]+  , sStartingContext = "Code"+  }
+ src/Skylighting/Syntax/Octave.hs view
@@ -0,0 +1,2933 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Octave (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Octave"+  , sFilename = "octave.xml"+  , sShortname = "Octave"+  , sContexts =+      fromList+        [ ( "_adjoint"+          , Context+              { cName = "_adjoint"+              , cSyntax = "Octave"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'+"+                              , reCompiled = Just (compileRegex True "'+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "_normal"+          , Context+              { cName = "_normal"+              , cSyntax = "Octave"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(for)\\b"+                              , reCompiled = Just (compileRegex True "\\b(for)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(endfor)\\b"+                              , reCompiled = Just (compileRegex True "\\b(endfor)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(if)\\b"+                              , reCompiled = Just (compileRegex True "\\b(if)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(endif)\\b"+                              , reCompiled = Just (compileRegex True "\\b(endif)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(do)\\b"+                              , reCompiled = Just (compileRegex True "\\b(do)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(until)\\b"+                              , reCompiled = Just (compileRegex True "\\b(until)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(while)\\b"+                              , reCompiled = Just (compileRegex True "\\b(while)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(endwhile)\\b"+                              , reCompiled = Just (compileRegex True "\\b(endwhile)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(function)\\b"+                              , reCompiled = Just (compileRegex True "\\b(function)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(endfunction)\\b"+                              , reCompiled = Just (compileRegex True "\\b(endfunction)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(switch)\\b"+                              , reCompiled = Just (compileRegex True "\\b(switch)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(endswitch)\\b"+                              , reCompiled = Just (compileRegex True "\\b(endswitch)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(try)\\b"+                              , reCompiled = Just (compileRegex True "\\b(try)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(end_try_catch)\\b"+                              , reCompiled = Just (compileRegex True "\\b(end_try_catch)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(end)\\b"+                              , reCompiled = Just (compileRegex True "\\b(end)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z]\\w*(?=')"+                              , reCompiled = Just (compileRegex True "[a-zA-Z]\\w*(?=')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Octave" , "_adjoint" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\d+(\\.\\d+)?|\\.\\d+)([eE][+-]?\\d+)?[ij]?(?=')"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(\\d+(\\.\\d+)?|\\.\\d+)([eE][+-]?\\d+)?[ij]?(?=')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Octave" , "_adjoint" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\)\\]}](?=')"+                              , reCompiled = Just (compileRegex True "[\\)\\]}](?=')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Octave" , "_adjoint" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.'(?=')"+                              , reCompiled = Just (compileRegex True "\\.'(?=')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Octave" , "_adjoint" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'([^'\\\\]|''|\\\\'|\\\\[^'])*'(?=[^']|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex True "'([^'\\\\]|''|\\\\'|\\\\[^'])*'(?=[^']|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'([^']|''|\\\\')*"+                              , reCompiled = Just (compileRegex True "'([^']|''|\\\\')*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"([^\"\\\\]|\"\"|\\\\\"|\\\\[^\"])*\"(?=[^\"]|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\"([^\"\\\\]|\"\"|\\\\\"|\\\\[^\"])*\"(?=[^\"]|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"([^\"]|\"\"|\\\\\")*"+                              , reCompiled = Just (compileRegex True "\"([^\"]|\"\"|\\\\\")*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "all_va_args"+                               , "break"+                               , "case"+                               , "continue"+                               , "else"+                               , "elseif"+                               , "end_unwind_protect"+                               , "global"+                               , "gplot"+                               , "gsplot"+                               , "otherwise"+                               , "persistent"+                               , "replot"+                               , "return"+                               , "static"+                               , "until"+                               , "unwind_protect"+                               , "unwind_protect_cleanup"+                               , "varargin"+                               , "varargout"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "__end__"+                               , "casesen"+                               , "cd"+                               , "chdir"+                               , "clear"+                               , "dbclear"+                               , "dbstatus"+                               , "dbstop"+                               , "dbtype"+                               , "dbwhere"+                               , "diary"+                               , "echo"+                               , "edit_history"+                               , "format"+                               , "gset"+                               , "gshow"+                               , "help"+                               , "history"+                               , "hold"+                               , "iskeyword"+                               , "isvarname"+                               , "load"+                               , "ls"+                               , "mark_as_command"+                               , "mislocked"+                               , "mlock"+                               , "more"+                               , "munlock"+                               , "run_history"+                               , "save"+                               , "set"+                               , "show"+                               , "type"+                               , "unmark_command"+                               , "which"+                               , "who"+                               , "whos"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "DEMOcontrol"+                               , "ERRNO"+                               , "__abcddims__"+                               , "__axis_label__"+                               , "__bodquist__"+                               , "__end__"+                               , "__errcomm__"+                               , "__error_text__"+                               , "__errplot__"+                               , "__freqresp__"+                               , "__outlist__"+                               , "__plr1__"+                               , "__plr2__"+                               , "__plr__"+                               , "__plt1__"+                               , "__plt2__"+                               , "__plt2mm__"+                               , "__plt2mv__"+                               , "__plt2ss__"+                               , "__plt2vm__"+                               , "__plt2vv__"+                               , "__plt__"+                               , "__pltopt1__"+                               , "__pltopt__"+                               , "__print_symbol_info__"+                               , "__print_symtab_info__"+                               , "__stepimp__"+                               , "__syschnamesl__"+                               , "__sysconcat__"+                               , "__syscont_disc__"+                               , "__sysdefioname__"+                               , "__sysdefstname__"+                               , "__sysgroupn__"+                               , "__tf2sysl__"+                               , "__tfl__"+                               , "__token_count__"+                               , "__zgpbal__"+                               , "__zp2ssg2__"+                               , "abcddim"+                               , "abs"+                               , "acos"+                               , "acosh"+                               , "acot"+                               , "acoth"+                               , "acsc"+                               , "acsch"+                               , "airy"+                               , "all"+                               , "analdemo"+                               , "angle"+                               , "anova"+                               , "any"+                               , "append"+                               , "arch_fit"+                               , "arch_rnd"+                               , "arch_test"+                               , "are"+                               , "arg"+                               , "argnames"+                               , "arma_rnd"+                               , "asctime"+                               , "asec"+                               , "asech"+                               , "asin"+                               , "asinh"+                               , "assignin"+                               , "atan"+                               , "atan2"+                               , "atanh"+                               , "atexit"+                               , "autocor"+                               , "autocov"+                               , "autoreg_matrix"+                               , "axis"+                               , "axis2dlim"+                               , "balance"+                               , "bar"+                               , "bartlett"+                               , "bartlett_test"+                               , "base2dec"+                               , "bddemo"+                               , "beep"+                               , "bessel"+                               , "besselh"+                               , "besseli"+                               , "besselj"+                               , "besselk"+                               , "bessely"+                               , "beta"+                               , "beta_cdf"+                               , "beta_inv"+                               , "beta_pdf"+                               , "beta_rnd"+                               , "betai"+                               , "betainc"+                               , "bin2dec"+                               , "bincoeff"+                               , "binomial_cdf"+                               , "binomial_inv"+                               , "binomial_pdf"+                               , "binomial_rnd"+                               , "bitand"+                               , "bitcmp"+                               , "bitget"+                               , "bitmax"+                               , "bitor"+                               , "bitset"+                               , "bitshift"+                               , "bitxor"+                               , "blackman"+                               , "blanks"+                               , "bode"+                               , "bode_bounds"+                               , "bottom_title"+                               , "bug_report"+                               , "buildssic"+                               , "c2d"+                               , "cart2pol"+                               , "cart2sph"+                               , "casesen"+                               , "cat"+                               , "cauchy_cdf"+                               , "cauchy_inv"+                               , "cauchy_pdf"+                               , "cauchy_rnd"+                               , "cd"+                               , "ceil"+                               , "cell"+                               , "cell2struct"+                               , "cellidx"+                               , "cellstr"+                               , "center"+                               , "char"+                               , "chdir"+                               , "chisquare_cdf"+                               , "chisquare_inv"+                               , "chisquare_pdf"+                               , "chisquare_rnd"+                               , "chisquare_test_homogeneity"+                               , "chisquare_test_independence"+                               , "chol"+                               , "circshift"+                               , "class"+                               , "clc"+                               , "clear"+                               , "clearplot"+                               , "clg"+                               , "clock"+                               , "cloglog"+                               , "close"+                               , "closeplot"+                               , "colloc"+                               , "colormap"+                               , "columns"+                               , "com2str"+                               , "comma"+                               , "common_size"+                               , "commutation_matrix"+                               , "compan"+                               , "complement"+                               , "completion_matches"+                               , "computer"+                               , "cond"+                               , "conj"+                               , "contour"+                               , "controldemo"+                               , "conv"+                               , "convmtx"+                               , "cor"+                               , "cor_test"+                               , "corrcoef"+                               , "cos"+                               , "cosh"+                               , "cot"+                               , "coth"+                               , "cov"+                               , "cputime"+                               , "create_set"+                               , "cross"+                               , "csc"+                               , "csch"+                               , "ctime"+                               , "ctrb"+                               , "cumprod"+                               , "cumsum"+                               , "cut"+                               , "d2c"+                               , "damp"+                               , "dare"+                               , "daspk"+                               , "daspk_options"+                               , "dasrt"+                               , "dasrt_options"+                               , "dassl"+                               , "dassl_options"+                               , "date"+                               , "dbclear"+                               , "dbstatus"+                               , "dbstop"+                               , "dbtype"+                               , "dbwhere"+                               , "dcgain"+                               , "deal"+                               , "deblank"+                               , "dec2base"+                               , "dec2bin"+                               , "dec2hex"+                               , "deconv"+                               , "delete"+                               , "demoquat"+                               , "det"+                               , "detrend"+                               , "dezero"+                               , "dftmtx"+                               , "dgkfdemo"+                               , "dgram"+                               , "dhinfdemo"+                               , "diag"+                               , "diary"+                               , "diff"+                               , "diffpara"+                               , "dir"+                               , "discrete_cdf"+                               , "discrete_inv"+                               , "discrete_pdf"+                               , "discrete_rnd"+                               , "disp"+                               , "dkalman"+                               , "dlqe"+                               , "dlqg"+                               , "dlqr"+                               , "dlyap"+                               , "dmr2d"+                               , "dmult"+                               , "do_string_escapes"+                               , "document"+                               , "dot"+                               , "double"+                               , "dre"+                               , "dump_prefs"+                               , "dup2"+                               , "duplication_matrix"+                               , "durbinlevinson"+                               , "echo"+                               , "edit_history"+                               , "eig"+                               , "empirical_cdf"+                               , "empirical_inv"+                               , "empirical_pdf"+                               , "empirical_rnd"+                               , "endgrent"+                               , "endpwent"+                               , "erf"+                               , "erfc"+                               , "erfinv"+                               , "error"+                               , "error_text"+                               , "errorbar"+                               , "etime"+                               , "eval"+                               , "evalin"+                               , "exec"+                               , "exist"+                               , "exit"+                               , "exp"+                               , "expm"+                               , "exponential_cdf"+                               , "exponential_inv"+                               , "exponential_pdf"+                               , "exponential_rnd"+                               , "eye"+                               , "f_cdf"+                               , "f_inv"+                               , "f_pdf"+                               , "f_rnd"+                               , "f_test_regression"+                               , "fclose"+                               , "fcntl"+                               , "fdisp"+                               , "feof"+                               , "ferror"+                               , "feval"+                               , "fflush"+                               , "fft"+                               , "fft2"+                               , "fftconv"+                               , "fftfilt"+                               , "fftn"+                               , "fftshift"+                               , "fftw_wisdom"+                               , "fgetl"+                               , "fgets"+                               , "fieldnames"+                               , "figure"+                               , "file_in_loadpath"+                               , "file_in_path"+                               , "fileparts"+                               , "filter"+                               , "find"+                               , "find_first_of_in_loadpath"+                               , "findstr"+                               , "finite"+                               , "fir2sys"+                               , "fix"+                               , "flipdim"+                               , "fliplr"+                               , "flipud"+                               , "floor"+                               , "flops"+                               , "fmod"+                               , "fnmatch"+                               , "fopen"+                               , "fork"+                               , "format"+                               , "formula"+                               , "fprintf"+                               , "fputs"+                               , "fractdiff"+                               , "frdemo"+                               , "fread"+                               , "freport"+                               , "freqchkw"+                               , "freqz"+                               , "freqz_plot"+                               , "frewind"+                               , "fscanf"+                               , "fseek"+                               , "fsolve"+                               , "fsolve_options"+                               , "ftell"+                               , "fullfile"+                               , "func2str"+                               , "functions"+                               , "fv"+                               , "fvl"+                               , "fwrite"+                               , "gamma"+                               , "gamma_cdf"+                               , "gamma_inv"+                               , "gamma_pdf"+                               , "gamma_rnd"+                               , "gammai"+                               , "gammainc"+                               , "gammaln"+                               , "gcd"+                               , "geometric_cdf"+                               , "geometric_inv"+                               , "geometric_pdf"+                               , "geometric_rnd"+                               , "getegid"+                               , "getenv"+                               , "geteuid"+                               , "getgid"+                               , "getgrent"+                               , "getgrgid"+                               , "getgrnam"+                               , "getpgrp"+                               , "getpid"+                               , "getppid"+                               , "getpwent"+                               , "getpwnam"+                               , "getpwuid"+                               , "getrusage"+                               , "getuid"+                               , "givens"+                               , "glob"+                               , "gls"+                               , "gmtime"+                               , "gram"+                               , "graw"+                               , "gray"+                               , "gray2ind"+                               , "grid"+                               , "gset"+                               , "gshow"+                               , "h2norm"+                               , "h2syn"+                               , "hamming"+                               , "hankel"+                               , "hanning"+                               , "help"+                               , "hess"+                               , "hex2dec"+                               , "hilb"+                               , "hinf_ctr"+                               , "hinfdemo"+                               , "hinfnorm"+                               , "hinfsyn"+                               , "hinfsyn_chk"+                               , "hinfsyn_ric"+                               , "hist"+                               , "history"+                               , "hold"+                               , "home"+                               , "horzcat"+                               , "hotelling_test"+                               , "hotelling_test_2"+                               , "housh"+                               , "hsv2rgb"+                               , "hurst"+                               , "hypergeometric_cdf"+                               , "hypergeometric_inv"+                               , "hypergeometric_pdf"+                               , "hypergeometric_rnd"+                               , "ifft"+                               , "ifft2"+                               , "ifftn"+                               , "imag"+                               , "image"+                               , "imagesc"+                               , "impulse"+                               , "imshow"+                               , "ind2gray"+                               , "ind2rgb"+                               , "ind2sub"+                               , "index"+                               , "inline"+                               , "input"+                               , "input_event_hook"+                               , "int16"+                               , "int2str"+                               , "int32"+                               , "int64"+                               , "int8"+                               , "intersection"+                               , "intmax"+                               , "intmin"+                               , "inv"+                               , "inverse"+                               , "invhilb"+                               , "ipermute"+                               , "iqr"+                               , "irr"+                               , "is_abcd"+                               , "is_bool"+                               , "is_complex"+                               , "is_controllable"+                               , "is_detectable"+                               , "is_dgkf"+                               , "is_digital"+                               , "is_duplicate_entry"+                               , "is_global"+                               , "is_leap_year"+                               , "is_list"+                               , "is_matrix"+                               , "is_nan_or_na"+                               , "is_observable"+                               , "is_sample"+                               , "is_scalar"+                               , "is_signal_list"+                               , "is_siso"+                               , "is_square"+                               , "is_stabilizable"+                               , "is_stable"+                               , "is_stream"+                               , "is_struct"+                               , "is_symmetric"+                               , "is_vector"+                               , "isa"+                               , "isalnum"+                               , "isalpha"+                               , "isascii"+                               , "isbool"+                               , "iscell"+                               , "iscellstr"+                               , "ischar"+                               , "iscntrl"+                               , "iscomplex"+                               , "isdefinite"+                               , "isdigit"+                               , "isempty"+                               , "isfield"+                               , "isfinite"+                               , "isglobal"+                               , "isgraph"+                               , "ishold"+                               , "isieee"+                               , "isinf"+                               , "iskeyword"+                               , "isletter"+                               , "islist"+                               , "islogical"+                               , "islower"+                               , "ismatrix"+                               , "isna"+                               , "isnan"+                               , "isnumeric"+                               , "ispc"+                               , "isprint"+                               , "ispunct"+                               , "isreal"+                               , "isscalar"+                               , "isspace"+                               , "issquare"+                               , "isstr"+                               , "isstream"+                               , "isstreamoff"+                               , "isstruct"+                               , "issymmetric"+                               , "isunix"+                               , "isupper"+                               , "isvarname"+                               , "isvector"+                               , "isxdigit"+                               , "jet707"+                               , "kbhit"+                               , "kendall"+                               , "keyboard"+                               , "kill"+                               , "kolmogorov_smirnov_cdf"+                               , "kolmogorov_smirnov_test"+                               , "kolmogorov_smirnov_test_2"+                               , "kron"+                               , "kruskal_wallis_test"+                               , "krylov"+                               , "krylovb"+                               , "kurtosis"+                               , "laplace_cdf"+                               , "laplace_inv"+                               , "laplace_pdf"+                               , "laplace_rnd"+                               , "lasterr"+                               , "lastwarn"+                               , "lcm"+                               , "length"+                               , "lgamma"+                               , "lin2mu"+                               , "link"+                               , "linspace"+                               , "list"+                               , "list_primes"+                               , "listidx"+                               , "load"+                               , "loadaudio"+                               , "loadimage"+                               , "localtime"+                               , "log"+                               , "log10"+                               , "log2"+                               , "logical"+                               , "logistic_cdf"+                               , "logistic_inv"+                               , "logistic_pdf"+                               , "logistic_regression"+                               , "logistic_regression_derivatives"+                               , "logistic_regression_likelihood"+                               , "logistic_rnd"+                               , "logit"+                               , "loglog"+                               , "loglogerr"+                               , "logm"+                               , "lognormal_cdf"+                               , "lognormal_inv"+                               , "lognormal_pdf"+                               , "lognormal_rnd"+                               , "logspace"+                               , "lower"+                               , "lpsolve"+                               , "lpsolve_options"+                               , "lqe"+                               , "lqg"+                               , "lqr"+                               , "ls"+                               , "lsim"+                               , "lsode"+                               , "lsode_options"+                               , "lstat"+                               , "ltifr"+                               , "lu"+                               , "lyap"+                               , "mahalanobis"+                               , "manova"+                               , "mark_as_command"+                               , "max"+                               , "mcnemar_test"+                               , "mean"+                               , "meansq"+                               , "median"+                               , "menu"+                               , "mesh"+                               , "meshdom"+                               , "meshgrid"+                               , "min"+                               , "minfo"+                               , "minmax"+                               , "mislocked"+                               , "mkdir"+                               , "mkfifo"+                               , "mkstemp"+                               , "mktime"+                               , "mlock"+                               , "mod"+                               , "moddemo"+                               , "moment"+                               , "more"+                               , "mplot"+                               , "mu2lin"+                               , "multiplot"+                               , "munlock"+                               , "nargchk"+                               , "nargin"+                               , "nargout"+                               , "native_float_format"+                               , "ndims"+                               , "nextpow2"+                               , "nichols"+                               , "norm"+                               , "normal_cdf"+                               , "normal_inv"+                               , "normal_pdf"+                               , "normal_rnd"+                               , "not"+                               , "nper"+                               , "npv"+                               , "nth"+                               , "ntsc2rgb"+                               , "null"+                               , "num2str"+                               , "numel"+                               , "nyquist"+                               , "obsv"+                               , "ocean"+                               , "octave_config_info"+                               , "octave_tmp_file_name"+                               , "odessa"+                               , "odessa_options"+                               , "ols"+                               , "oneplot"+                               , "ones"+                               , "ord2"+                               , "orth"+                               , "pack"+                               , "packedform"+                               , "packsys"+                               , "parallel"+                               , "paren"+                               , "pascal_cdf"+                               , "pascal_inv"+                               , "pascal_pdf"+                               , "pascal_rnd"+                               , "path"+                               , "pause"+                               , "pclose"+                               , "periodogram"+                               , "permute"+                               , "perror"+                               , "pinv"+                               , "pipe"+                               , "place"+                               , "playaudio"+                               , "plot"+                               , "plot_border"+                               , "pmt"+                               , "poisson_cdf"+                               , "poisson_inv"+                               , "poisson_pdf"+                               , "poisson_rnd"+                               , "pol2cart"+                               , "polar"+                               , "poly"+                               , "polyder"+                               , "polyderiv"+                               , "polyfit"+                               , "polyinteg"+                               , "polyout"+                               , "polyreduce"+                               , "polyval"+                               , "polyvalm"+                               , "popen"+                               , "popen2"+                               , "postpad"+                               , "pow2"+                               , "ppplot"+                               , "prepad"+                               , "printf"+                               , "probit"+                               , "prod"+                               , "prompt"+                               , "prop_test_2"+                               , "purge_tmp_files"+                               , "putenv"+                               , "puts"+                               , "pv"+                               , "pvl"+                               , "pwd"+                               , "pzmap"+                               , "qconj"+                               , "qcoordinate_plot"+                               , "qderiv"+                               , "qderivmat"+                               , "qinv"+                               , "qmult"+                               , "qqplot"+                               , "qr"+                               , "qtrans"+                               , "qtransv"+                               , "qtransvmat"+                               , "quad"+                               , "quad_options"+                               , "quaternion"+                               , "quit"+                               , "qz"+                               , "qzhess"+                               , "qzval"+                               , "rand"+                               , "randn"+                               , "randperm"+                               , "range"+                               , "rank"+                               , "ranks"+                               , "rate"+                               , "read_readline_init_file"+                               , "readdir"+                               , "readlink"+                               , "real"+                               , "record"+                               , "rectangle_lw"+                               , "rectangle_sw"+                               , "rehash"+                               , "rem"+                               , "rename"+                               , "repmat"+                               , "reshape"+                               , "residue"+                               , "reverse"+                               , "rgb2hsv"+                               , "rgb2ind"+                               , "rgb2ntsc"+                               , "rindex"+                               , "rldemo"+                               , "rlocus"+                               , "rmdir"+                               , "rmfield"+                               , "roots"+                               , "rot90"+                               , "rotdim"+                               , "rotg"+                               , "round"+                               , "rows"+                               , "run_cmd"+                               , "run_count"+                               , "run_history"+                               , "run_test"+                               , "save"+                               , "saveaudio"+                               , "saveimage"+                               , "scanf"+                               , "schur"+                               , "sec"+                               , "sech"+                               , "semicolon"+                               , "semilogx"+                               , "semilogxerr"+                               , "semilogy"+                               , "semilogyerr"+                               , "series"+                               , "set"+                               , "setaudio"+                               , "setgrent"+                               , "setpwent"+                               , "setstr"+                               , "shell_cmd"+                               , "shg"+                               , "shift"+                               , "shiftdim"+                               , "show"+                               , "sign"+                               , "sign_test"+                               , "sin"+                               , "sinc"+                               , "sinetone"+                               , "sinewave"+                               , "sinh"+                               , "size"+                               , "sizeof"+                               , "skewness"+                               , "sleep"+                               , "sombrero"+                               , "sort"+                               , "sortcom"+                               , "source"+                               , "spearman"+                               , "spectral_adf"+                               , "spectral_xdf"+                               , "spencer"+                               , "sph2cart"+                               , "splice"+                               , "split"+                               , "sprintf"+                               , "sqrt"+                               , "sqrtm"+                               , "squeeze"+                               , "ss"+                               , "ss2sys"+                               , "ss2tf"+                               , "ss2zp"+                               , "sscanf"+                               , "stairs"+                               , "starp"+                               , "stat"+                               , "statistics"+                               , "std"+                               , "stdnormal_cdf"+                               , "stdnormal_inv"+                               , "stdnormal_pdf"+                               , "stdnormal_rnd"+                               , "step"+                               , "stft"+                               , "str2func"+                               , "str2mat"+                               , "str2num"+                               , "strappend"+                               , "strcat"+                               , "strcmp"+                               , "streamoff"+                               , "strerror"+                               , "strftime"+                               , "strjust"+                               , "strptime"+                               , "strrep"+                               , "struct"+                               , "struct2cell"+                               , "struct_contains"+                               , "struct_elements"+                               , "studentize"+                               , "sub2ind"+                               , "subplot"+                               , "substr"+                               , "subwindow"+                               , "sum"+                               , "sumsq"+                               , "svd"+                               , "swap"+                               , "swapcols"+                               , "swaprows"+                               , "syl"+                               , "sylvester_matrix"+                               , "symlink"+                               , "synthesis"+                               , "sys2fir"+                               , "sys2ss"+                               , "sys2tf"+                               , "sys2zp"+                               , "sysadd"+                               , "sysappend"+                               , "syschnames"+                               , "syschtsam"+                               , "sysconnect"+                               , "syscont"+                               , "sysdimensions"+                               , "sysdisc"+                               , "sysdup"+                               , "sysgetsignals"+                               , "sysgettsam"+                               , "sysgettype"+                               , "sysgroup"+                               , "sysidx"+                               , "sysmin"+                               , "sysmult"+                               , "sysout"+                               , "sysprune"+                               , "sysreorder"+                               , "sysrepdemo"+                               , "sysscale"+                               , "syssetsignals"+                               , "syssub"+                               , "system"+                               , "sysupdate"+                               , "t_cdf"+                               , "t_inv"+                               , "t_pdf"+                               , "t_rnd"+                               , "t_test"+                               , "t_test_2"+                               , "t_test_regression"+                               , "table"+                               , "tan"+                               , "tanh"+                               , "tempdir"+                               , "tempname"+                               , "texas_lotto"+                               , "tf"+                               , "tf2ss"+                               , "tf2sys"+                               , "tf2zp"+                               , "tfout"+                               , "tic"+                               , "tilde_expand"+                               , "time"+                               , "title"+                               , "tmpfile"+                               , "tmpnam"+                               , "toascii"+                               , "toc"+                               , "toeplitz"+                               , "tolower"+                               , "top_title"+                               , "toupper"+                               , "trace"+                               , "triangle_lw"+                               , "triangle_sw"+                               , "tril"+                               , "triu"+                               , "type"+                               , "typeinfo"+                               , "tzero"+                               , "tzero2"+                               , "u_test"+                               , "ugain"+                               , "uint16"+                               , "uint32"+                               , "uint64"+                               , "uint8"+                               , "umask"+                               , "undo_string_escapes"+                               , "uniform_cdf"+                               , "uniform_inv"+                               , "uniform_pdf"+                               , "uniform_rnd"+                               , "union"+                               , "unix"+                               , "unlink"+                               , "unmark_command"+                               , "unpacksys"+                               , "unwrap"+                               , "upper"+                               , "usage"+                               , "usleep"+                               , "va_arg"+                               , "va_start"+                               , "values"+                               , "vander"+                               , "var"+                               , "var_test"+                               , "vec"+                               , "vech"+                               , "vectorize"+                               , "version"+                               , "vertcat"+                               , "vol"+                               , "vr_val"+                               , "waitpid"+                               , "warning"+                               , "warranty"+                               , "weibull_cdf"+                               , "weibull_inv"+                               , "weibull_pdf"+                               , "weibull_rnd"+                               , "welch_test"+                               , "wgt1o"+                               , "which"+                               , "who"+                               , "whos"+                               , "wiener_rnd"+                               , "wilcoxon_test"+                               , "xlabel"+                               , "xor"+                               , "ylabel"+                               , "yulewalker"+                               , "z_test"+                               , "z_test_2"+                               , "zeros"+                               , "zgfmul"+                               , "zgfslv"+                               , "zginit"+                               , "zgreduce"+                               , "zgrownorm"+                               , "zgscal"+                               , "zgsgiv"+                               , "zgshsr"+                               , "zlabel"+                               , "zp"+                               , "zp2ss"+                               , "zp2sys"+                               , "zp2tf"+                               , "zpout"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "DEFAULT_EXEC_PATH"+                               , "DEFAULT_LOADPATH"+                               , "EDITOR"+                               , "EXEC_PATH"+                               , "FFTW_WISDOM_PROGRAM"+                               , "F_DUPFD"+                               , "F_GETFD"+                               , "F_GETFL"+                               , "F_SETFD"+                               , "F_SETFL"+                               , "I"+                               , "IMAGEPATH"+                               , "INFO_FILE"+                               , "INFO_PROGRAM"+                               , "Inf"+                               , "J"+                               , "LOADPATH"+                               , "MAKEINFO_PROGRAM"+                               , "NA"+                               , "NaN"+                               , "OCTAVE_HOME"+                               , "OCTAVE_VERSION"+                               , "O_APPEND"+                               , "O_ASYNC"+                               , "O_CREAT"+                               , "O_EXCL"+                               , "O_NONBLOCK"+                               , "O_RDONLY"+                               , "O_RDWR"+                               , "O_SYNC"+                               , "O_TRUNC"+                               , "O_WRONLY"+                               , "PAGER"+                               , "PS1"+                               , "PS2"+                               , "PS4"+                               , "P_tmpdir"+                               , "SEEK_CUR"+                               , "SEEK_END"+                               , "SEEK_SET"+                               , "SIG"+                               , "__kluge_procbuf_delay__"+                               , "ans"+                               , "argv"+                               , "automatic_replot"+                               , "beep_on_error"+                               , "completion_append_char"+                               , "crash_dumps_octave_core"+                               , "current_script_file_name"+                               , "debug_on_error"+                               , "debug_on_interrupt"+                               , "debug_on_warning"+                               , "debug_symtab_lookups"+                               , "default_save_format"+                               , "e"+                               , "echo_executing_commands"+                               , "eps"+                               , "false"+                               , "filesep"+                               , "fixed_point_format"+                               , "gnuplot_binary"+                               , "gnuplot_command_axes"+                               , "gnuplot_command_end"+                               , "gnuplot_command_plot"+                               , "gnuplot_command_replot"+                               , "gnuplot_command_splot"+                               , "gnuplot_command_title"+                               , "gnuplot_command_using"+                               , "gnuplot_command_with"+                               , "gnuplot_has_frames"+                               , "history_file"+                               , "history_size"+                               , "i"+                               , "ignore_function_time_stamp"+                               , "inf"+                               , "j"+                               , "max_recursion_depth"+                               , "nan"+                               , "octave_core_file_format"+                               , "octave_core_file_limit"+                               , "octave_core_file_name"+                               , "output_max_field_width"+                               , "output_precision"+                               , "page_output_immediately"+                               , "page_screen_output"+                               , "pi"+                               , "print_answer_id_name"+                               , "print_empty_dimensions"+                               , "print_rhs_assign_val"+                               , "program_invocation_name"+                               , "program_name"+                               , "realmax"+                               , "realmin"+                               , "save_header_format_string"+                               , "save_precision"+                               , "saving_history"+                               , "sighup_dumps_octave_core"+                               , "sigterm_dumps_octave_core"+                               , "silent_functions"+                               , "split_long_rows"+                               , "stderr"+                               , "stdin"+                               , "stdout"+                               , "string_fill_char"+                               , "struct_levels_to_print"+                               , "suppress_verbose_help_message"+                               , "true"+                               , "variables_can_hide_functions"+                               , "warn_assign_as_truth_value"+                               , "warn_divide_by_zero"+                               , "warn_empty_list_elements"+                               , "warn_fortran_indexing"+                               , "warn_function_name_clash"+                               , "warn_future_time_stamp"+                               , "warn_imag_to_real"+                               , "warn_matlab_incompatible"+                               , "warn_missing_semicolon"+                               , "warn_neg_dim_as_zero"+                               , "warn_num_to_str"+                               , "warn_precedence_change"+                               , "warn_reload_forces_clear"+                               , "warn_resize_on_range_error"+                               , "warn_separator_insert"+                               , "warn_single_quote_string"+                               , "warn_str_to_num"+                               , "warn_undefined_return_values"+                               , "warn_variable_switch_label"+                               , "whos_line_format"+                               ])+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "BandToFull"+                               , "BandToSparse"+                               , "Chi"+                               , "Ci"+                               , "Contents"+                               , "ExampleEigenValues"+                               , "ExampleGenEigenValues"+                               , "FullToBand"+                               , "MakeShears"+                               , "OCTAVE_FORGE_VERSION"+                               , "SBBacksub"+                               , "SBEig"+                               , "SBFactor"+                               , "SBProd"+                               , "SBSolve"+                               , "Shi"+                               , "Si"+                               , "SymBand"+                               , "__ellip_ws"+                               , "__ellip_ws_min"+                               , "__grcla__"+                               , "__grclf__"+                               , "__grcmd__"+                               , "__grexit__"+                               , "__grfigure__"+                               , "__grgetstat__"+                               , "__grhold__"+                               , "__grinit__"+                               , "__grishold__"+                               , "__grnewset__"+                               , "__grsetgraph__"+                               , "__nlnewmark_fcn__"+                               , "__plt3__"+                               , "__power"+                               , "_errcore"+                               , "_gfweight"+                               , "aar"+                               , "aarmam"+                               , "ac2poly"+                               , "ac2rc"+                               , "acorf"+                               , "acovf"+                               , "addpath"+                               , "ademodce"+                               , "adim"+                               , "adsmax"+                               , "airy_Ai"+                               , "airy_Ai_deriv"+                               , "airy_Ai_deriv_scaled"+                               , "airy_Ai_scaled"+                               , "airy_Bi"+                               , "airy_Bi_deriv"+                               , "airy_Bi_deriv_scaled"+                               , "airy_Bi_scaled"+                               , "airy_zero_Ai"+                               , "airy_zero_Ai_deriv"+                               , "airy_zero_Bi"+                               , "airy_zero_Bi_deriv"+                               , "amodce"+                               , "anderson_darling_cdf"+                               , "anderson_darling_test"+                               , "anovan"+                               , "apkconst"+                               , "append_save"+                               , "applylut"+                               , "ar2poly"+                               , "ar2rc"+                               , "ar_spa"+                               , "arburg"+                               , "arcext"+                               , "arfit2"+                               , "aryule"+                               , "assert"+                               , "atanint"+                               , "au"+                               , "aucapture"+                               , "auload"+                               , "auplot"+                               , "aurecord"+                               , "ausave"+                               , "autumn"+                               , "average_moments"+                               , "awgn"+                               , "azimuth"+                               , "base64encode"+                               , "battery"+                               , "bchdeco"+                               , "bchenco"+                               , "bchpoly"+                               , "bessel_In"+                               , "bessel_In_scaled"+                               , "bessel_Inu"+                               , "bessel_Inu_scaled"+                               , "bessel_Jn"+                               , "bessel_Jnu"+                               , "bessel_Kn"+                               , "bessel_Kn_scaled"+                               , "bessel_Knu"+                               , "bessel_Knu_scaled"+                               , "bessel_Yn"+                               , "bessel_Ynu"+                               , "bessel_il_scaled"+                               , "bessel_jl"+                               , "bessel_kl_scaled"+                               , "bessel_lnKnu"+                               , "bessel_yl"+                               , "bessel_zero_J0"+                               , "bessel_zero_J1"+                               , "best_dir"+                               , "best_dir_cov"+                               , "bestblk"+                               , "beta_gsl"+                               , "betaln"+                               , "bfgs"+                               , "bfgsmin"+                               , "bfgsmin_example"+                               , "bi2de"+                               , "biacovf"+                               , "bilinear"+                               , "bisdemo"+                               , "bisectionstep"+                               , "bispec"+                               , "biterr"+                               , "blkdiag"+                               , "blkproc"+                               , "bmpwrite"+                               , "bone"+                               , "bound_convex"+                               , "boxcar"+                               , "boxplot"+                               , "brighten"+                               , "bs_gradient"+                               , "builtin"+                               , "butter"+                               , "buttord"+                               , "bwborder"+                               , "bweuler"+                               , "bwfill"+                               , "bwlabel"+                               , "bwmorph"+                               , "bwselect"+                               , "calendar"+                               , "cceps"+                               , "cdiff"+                               , "cell2csv"+                               , "celleval"+                               , "cellstr"+                               , "char"+                               , "cheb"+                               , "cheb1ord"+                               , "cheb2ord"+                               , "chebwin"+                               , "cheby1"+                               , "cheby2"+                               , "chirp"+                               , "chol"+                               , "clausen"+                               , "clf"+                               , "clip"+                               , "cmpermute"+                               , "cmunique"+                               , "cohere"+                               , "col2im"+                               , "colfilt"+                               , "colorgradient"+                               , "comms"+                               , "compand"+                               , "complex"+                               , "concat"+                               , "conicalP_0"+                               , "conicalP_1"+                               , "conicalP_half"+                               , "conicalP_mhalf"+                               , "conndef"+                               , "content"+                               , "contents"+                               , "contourf"+                               , "conv2"+                               , "convhull"+                               , "convmtx"+                               , "cool"+                               , "copper"+                               , "cordflt2"+                               , "corr2"+                               , "cosets"+                               , "count"+                               , "coupling_3j"+                               , "coupling_6j"+                               , "coupling_9j"+                               , "covm"+                               , "cplxpair"+                               , "cquadnd"+                               , "create_lookup_table"+                               , "crule"+                               , "crule2d"+                               , "crule2dgen"+                               , "csape"+                               , "csapi"+                               , "csd"+                               , "csv2cell"+                               , "csvconcat"+                               , "csvexplode"+                               , "csvread"+                               , "csvwrite"+                               , "ctranspose"+                               , "cumtrapz"+                               , "cyclgen"+                               , "cyclpoly"+                               , "czt"+                               , "d2_min"+                               , "datenum"+                               , "datestr"+                               , "datevec"+                               , "dawson"+                               , "dct"+                               , "dct2"+                               , "dctmtx"+                               , "de2bi"+                               , "deal"+                               , "debye_1"+                               , "debye_2"+                               , "debye_3"+                               , "debye_4"+                               , "decimate"+                               , "decode"+                               , "deg2rad"+                               , "del2"+                               , "delaunay"+                               , "delaunay3"+                               , "delta_method"+                               , "demo"+                               , "demodmap"+                               , "deref"+                               , "deriv"+                               , "detrend"+                               , "dfdp"+                               , "dftmtx"+                               , "dhbar"+                               , "dilate"+                               , "dispatch"+                               , "dispatch_help"+                               , "display_fixed_operations"+                               , "distance"+                               , "dlmread"+                               , "dlmwrite"+                               , "dos"+                               , "double"+                               , "drawnow"+                               , "durlev"+                               , "dxfwrite"+                               , "edge"+                               , "edit"+                               , "ellint_Ecomp"+                               , "ellint_Kcomp"+                               , "ellip"+                               , "ellipdemo"+                               , "ellipj"+                               , "ellipke"+                               , "ellipord"+                               , "encode"+                               , "eomday"+                               , "erf_Q"+                               , "erf_Z"+                               , "erf_gsl"+                               , "erfc_gsl"+                               , "erode"+                               , "eta"+                               , "eta_int"+                               , "example"+                               , "exp_mult"+                               , "expdemo"+                               , "expfit"+                               , "expint_3"+                               , "expint_E1"+                               , "expint_E2"+                               , "expint_Ei"+                               , "expm1"+                               , "exprel"+                               , "exprel_2"+                               , "exprel_n"+                               , "eyediagram"+                               , "fabs"+                               , "factor"+                               , "factorial"+                               , "fail"+                               , "fangle"+                               , "farg"+                               , "fatan2"+                               , "fceil"+                               , "fcnchk"+                               , "fconj"+                               , "fcos"+                               , "fcosh"+                               , "fcumprod"+                               , "fcumsum"+                               , "fdiag"+                               , "feedback"+                               , "fem_test"+                               , "fermi_dirac_3half"+                               , "fermi_dirac_half"+                               , "fermi_dirac_inc_0"+                               , "fermi_dirac_int"+                               , "fermi_dirac_mhalf"+                               , "fexp"+                               , "ff2n"+                               , "ffloor"+                               , "fftconv2"+                               , "fieldnames"+                               , "fill"+                               , "fill3"+                               , "filter2"+                               , "filtfilt"+                               , "filtic"+                               , "fimag"+                               , "findsym"+                               , "finitedifference"+                               , "fir1"+                               , "fir2"+                               , "fixed"+                               , "fixedpoint"+                               , "flag"+                               , "flag_implicit_samplerate"+                               , "flattopwin"+                               , "flix"+                               , "float"+                               , "flog"+                               , "flog10"+                               , "fmin"+                               , "fminbnd"+                               , "fmins"+                               , "fminunc"+                               , "fnder"+                               , "fnplt"+                               , "fnval"+                               , "fplot"+                               , "fprod"+                               , "freal"+                               , "freqs"+                               , "freqs_plot"+                               , "freshape"+                               , "fround"+                               , "fsin"+                               , "fsinh"+                               , "fsort"+                               , "fsqrt"+                               , "fsum"+                               , "fsumsq"+                               , "ftan"+                               , "ftanh"+                               , "full"+                               , "fullfact"+                               , "funm"+                               , "fzero"+                               , "gamma_gsl"+                               , "gamma_inc"+                               , "gamma_inc_P"+                               , "gamma_inc_Q"+                               , "gammainv_gsl"+                               , "gammaln"+                               , "gammastar"+                               , "gapTest"+                               , "gaussian"+                               , "gausswin"+                               , "gconv"+                               , "gconvmtx"+                               , "gdeconv"+                               , "gdet"+                               , "gdftmtx"+                               , "gdiag"+                               , "gen2par"+                               , "geomean"+                               , "getfield"+                               , "getfields"+                               , "gexp"+                               , "gf"+                               , "gfft"+                               , "gfilter"+                               , "gftable"+                               , "gfweight"+                               , "gget"+                               , "gifft"+                               , "ginput"+                               , "ginv"+                               , "ginverse"+                               , "glog"+                               , "glu"+                               , "gmm_estimate"+                               , "gmm_example"+                               , "gmm_obj"+                               , "gmm_results"+                               , "gmm_variance"+                               , "gmm_variance_inefficient"+                               , "gpick"+                               , "gprod"+                               , "gquad"+                               , "gquad2d"+                               , "gquad2d6"+                               , "gquad2dgen"+                               , "gquad6"+                               , "gquadnd"+                               , "grab"+                               , "grace_octave_path"+                               , "gradient"+                               , "grank"+                               , "graycomatrix"+                               , "grayslice"+                               , "grep"+                               , "greshape"+                               , "grid"+                               , "griddata"+                               , "groots"+                               , "grpdelay"+                               , "grule"+                               , "grule2d"+                               , "grule2dgen"+                               , "gsl_sf"+                               , "gsqrt"+                               , "gsum"+                               , "gsumsq"+                               , "gtext"+                               , "gzoom"+                               , "hadamard"+                               , "hammgen"+                               , "hankel"+                               , "hann"+                               , "harmmean"+                               , "hazard"+                               , "hilbert"+                               , "histeq"+                               , "histfit"+                               , "histo"+                               , "histo2"+                               , "histo3"+                               , "histo4"+                               , "hot"+                               , "houghtf"+                               , "hsv"+                               , "hup"+                               , "hyperg_0F1"+                               , "hzeta"+                               , "idct"+                               , "idct2"+                               , "idplot"+                               , "idsim"+                               , "ifftshift"+                               , "im2bw"+                               , "im2col"+                               , "imadjust"+                               , "imginfo"+                               , "imhist"+                               , "imnoise"+                               , "impad"+                               , "impz"+                               , "imread"+                               , "imrotate"+                               , "imshear"+                               , "imtranslate"+                               , "imwrite"+                               , "innerfun"+                               , "inputname"+                               , "interp"+                               , "interp1"+                               , "interp2"+                               , "interpft"+                               , "intersect"+                               , "invest0"+                               , "invest1"+                               , "invfdemo"+                               , "invfreq"+                               , "invfreqs"+                               , "invfreqz"+                               , "inz"+                               , "irsa_act"+                               , "irsa_actcore"+                               , "irsa_check"+                               , "irsa_dft"+                               , "irsa_dftfp"+                               , "irsa_genreal"+                               , "irsa_idft"+                               , "irsa_isregular"+                               , "irsa_jitsp"+                               , "irsa_mdsp"+                               , "irsa_normalize"+                               , "irsa_plotdft"+                               , "irsa_resample"+                               , "irsa_rgenreal"+                               , "is_complex_sparse"+                               , "is_real_sparse"+                               , "is_sparse"+                               , "isa"+                               , "isbw"+                               , "isdir"+                               , "isequal"+                               , "isfield"+                               , "isfixed"+                               , "isgalois"+                               , "isgray"+                               , "isind"+                               , "ismember"+                               , "isprime"+                               , "isprimitive"+                               , "isrgb"+                               , "issparse"+                               , "isunix"+                               , "jet"+                               , "jpgread"+                               , "jpgwrite"+                               , "kaiser"+                               , "kaiserord"+                               , "lambert_W0"+                               , "lambert_Wm1"+                               , "lambertw"+                               , "lattice"+                               , "lauchli"+                               , "leasqr"+                               , "leasqrdemo"+                               , "legend"+                               , "legendre"+                               , "legendre_Pl"+                               , "legendre_Plm"+                               , "legendre_Ql"+                               , "legendre_sphPlm"+                               , "legendre_sphPlm_array"+                               , "leval"+                               , "levinson"+                               , "lin2mu"+                               , "line_min"+                               , "listen"+                               , "lloyds"+                               , "lnbeta"+                               , "lncosh"+                               , "lngamma_gsl"+                               , "lnpoch"+                               , "lnsinh"+                               , "log_1plusx"+                               , "log_1plusx_mx"+                               , "log_erfc"+                               , "lookup"+                               , "lookup_table"+                               , "lp"+                               , "lp_test"+                               , "lpc"+                               , "mad"+                               , "magic"+                               , "make_sparse"+                               , "makelut"+                               , "map"+                               , "mark_for_deletion"+                               , "mat2gray"+                               , "mat2str"+                               , "mdsmax"+                               , "mean2"+                               , "medfilt1"+                               , "medfilt2"+                               , "meshc"+                               , "minimize"+                               , "minpol"+                               , "mkpp"+                               , "mktheta"+                               , "mle_estimate"+                               , "mle_example"+                               , "mle_obj"+                               , "mle_results"+                               , "mle_variance"+                               , "modmap"+                               , "mu2lin"+                               , "mvaar"+                               , "mvar"+                               , "mvfilter"+                               , "mvfreqz"+                               , "myfeval"+                               , "nanmax"+                               , "nanmean"+                               , "nanmedian"+                               , "nanmin"+                               , "nanstd"+                               , "nansum"+                               , "ncauer"+                               , "nchoosek"+                               , "ncrule"+                               , "ndims"+                               , "nelder_mead_min"+                               , "newmark"+                               , "newtonstep"+                               , "nlfilter"+                               , "nlnewmark"+                               , "nmsmax"+                               , "nnz"+                               , "nonzeros"+                               , "normplot"+                               , "now"+                               , "nrm"+                               , "nthroot"+                               , "numgradient"+                               , "numhessian"+                               , "nze"+                               , "ode23"+                               , "ode45"+                               , "ode78"+                               , "optimset"+                               , "ordfilt2"+                               , "orient"+                               , "pacf"+                               , "padarray"+                               , "parameterize"+                               , "parcor"+                               , "pareto"+                               , "pascal"+                               , "patch"+                               , "pburg"+                               , "pcg"+                               , "pchip"+                               , "pchip_deriv"+                               , "pcolor"+                               , "pcr"+                               , "peaks"+                               , "penddot"+                               , "pendulum"+                               , "perms"+                               , "pie"+                               , "pink"+                               , "plot3"+                               , "pngread"+                               , "pngwrite"+                               , "poch"+                               , "pochrel"+                               , "poly2ac"+                               , "poly2ar"+                               , "poly2mask"+                               , "poly2rc"+                               , "poly2sym"+                               , "poly2th"+                               , "poly_2_ex"+                               , "polyarea"+                               , "polyconf"+                               , "polyder"+                               , "polyderiv"+                               , "polygcd"+                               , "polystab"+                               , "ppval"+                               , "prctile"+                               , "pretty"+                               , "prettyprint"+                               , "prettyprint_c"+                               , "primes"+                               , "primpoly"+                               , "princomp"+                               , "print"+                               , "prism"+                               , "proplan"+                               , "psi"+                               , "psi_1_int"+                               , "psi_1piy"+                               , "psi_n"+                               , "pulstran"+                               , "pwelch"+                               , "pyulear"+                               , "qaskdeco"+                               , "qaskenco"+                               , "qtdecomp"+                               , "qtgetblk"+                               , "qtsetblk"+                               , "quad2dc"+                               , "quad2dcgen"+                               , "quad2dg"+                               , "quad2dggen"+                               , "quadc"+                               , "quadg"+                               , "quadl"+                               , "quadndg"+                               , "quantiz"+                               , "quiver"+                               , "rad2deg"+                               , "rainbow"+                               , "rand"+                               , "rande"+                               , "randerr"+                               , "randint"+                               , "randn"+                               , "randp"+                               , "randsrc"+                               , "rat"+                               , "rats"+                               , "rc2ac"+                               , "rc2ar"+                               , "rc2poly"+                               , "rceps"+                               , "read_options"+                               , "read_pdb"+                               , "rectpuls"+                               , "regexp"+                               , "remez"+                               , "resample"+                               , "reset_fixed_operations"+                               , "rgb2gray"+                               , "rk2fixed"+                               , "rk4fixed"+                               , "rk8fixed"+                               , "rmfield"+                               , "rmle"+                               , "rmpath"+                               , "roicolor"+                               , "rosser"+                               , "rotate_scale"+                               , "rotparams"+                               , "rotv"+                               , "rref"+                               , "rsdec"+                               , "rsdecof"+                               , "rsenc"+                               , "rsencof"+                               , "rsgenpoly"+                               , "samin"+                               , "samin_example"+                               , "save_vrml"+                               , "sbispec"+                               , "scale_data"+                               , "scatter"+                               , "scatterplot"+                               , "select_3D_points"+                               , "selmo"+                               , "setdiff"+                               , "setfield"+                               , "setfields"+                               , "setxor"+                               , "sftrans"+                               , "sgolay"+                               , "sgolayfilt"+                               , "sinc_gsl"+                               , "sinvest1"+                               , "slurp_file"+                               , "sortrows"+                               , "sound"+                               , "soundsc"+                               , "sp_test"+                               , "spabs"+                               , "sparse"+                               , "spdiags"+                               , "specgram"+                               , "speed"+                               , "speye"+                               , "spfind"+                               , "spfun"+                               , "sphcat"+                               , "spimag"+                               , "spinv"+                               , "spline"+                               , "splot"+                               , "splu"+                               , "spones"+                               , "sprand"+                               , "sprandn"+                               , "spreal"+                               , "spring"+                               , "spstats"+                               , "spsum"+                               , "sptest"+                               , "spvcat"+                               , "spy"+                               , "std2"+                               , "stem"+                               , "str2double"+                               , "strcmpi"+                               , "stretchlim"+                               , "strfind"+                               , "strmatch"+                               , "strncmp"+                               , "strncmpi"+                               , "strsort"+                               , "strtok"+                               , "strtoz"+                               , "struct"+                               , "strvcat"+                               , "summer"+                               , "sumskipnan"+                               , "surf"+                               , "surfc"+                               , "sym2poly"+                               , "symerr"+                               , "symfsolve"+                               , "synchrotron_1"+                               , "synchrotron_2"+                               , "syndtable"+                               , "tabulate"+                               , "tar"+                               , "taylorcoeff"+                               , "temp_name"+                               , "test"+                               , "test_d2_min_1"+                               , "test_d2_min_2"+                               , "test_d2_min_3"+                               , "test_ellipj"+                               , "test_fminunc_1"+                               , "test_inline_1"+                               , "test_min_1"+                               , "test_min_2"+                               , "test_min_3"+                               , "test_min_4"+                               , "test_minimize_1"+                               , "test_nelder_mead_min_1"+                               , "test_nelder_mead_min_2"+                               , "test_sncndn"+                               , "test_struct"+                               , "test_vmesh"+                               , "test_vrml_faces"+                               , "test_wpolyfit"+                               , "testimio"+                               , "text"+                               , "textread"+                               , "tf2zp"+                               , "tfe"+                               , "thfm"+                               , "tics"+                               , "toeplitz"+                               , "toggle_grace_use"+                               , "transport_2"+                               , "transport_3"+                               , "transport_4"+                               , "transport_5"+                               , "transpose"+                               , "trapz"+                               , "triang"+                               , "tril"+                               , "trimmean"+                               , "tripuls"+                               , "trisolve"+                               , "triu"+                               , "tsademo"+                               , "tsearchdemo"+                               , "ucp"+                               , "uintlut"+                               , "unique"+                               , "unix"+                               , "unmkpp"+                               , "unscale_parameters"+                               , "vec2mat"+                               , "view"+                               , "vmesh"+                               , "voronoi"+                               , "voronoin"+                               , "vrml_Background"+                               , "vrml_PointLight"+                               , "vrml_arrow"+                               , "vrml_browse"+                               , "vrml_cyl"+                               , "vrml_demo_tutorial_1"+                               , "vrml_demo_tutorial_2"+                               , "vrml_demo_tutorial_3"+                               , "vrml_demo_tutorial_4"+                               , "vrml_ellipsoid"+                               , "vrml_faces"+                               , "vrml_flatten"+                               , "vrml_frame"+                               , "vrml_group"+                               , "vrml_kill"+                               , "vrml_lines"+                               , "vrml_material"+                               , "vrml_parallelogram"+                               , "vrml_points"+                               , "vrml_select_points"+                               , "vrml_surf"+                               , "vrml_text"+                               , "vrml_thick_surf"+                               , "vrml_transfo"+                               , "waitbar"+                               , "wavread"+                               , "wavwrite"+                               , "weekday"+                               , "wgn"+                               , "white"+                               , "wilkinson"+                               , "winter"+                               , "wpolyfit"+                               , "wpolyfitdemo"+                               , "write_pdb"+                               , "wsolve"+                               , "xcorr"+                               , "xcorr2"+                               , "xcov"+                               , "xlsread"+                               , "xmlread"+                               , "xmlwrite"+                               , "y2res"+                               , "zero_count"+                               , "zeta"+                               , "zeta_int"+                               , "zoom"+                               , "zp2tf"+                               , "zplane"+                               , "zscore"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[%#].*$"+                              , reCompiled = Just (compileRegex True "[%#].*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z]\\w*"+                              , reCompiled = Just (compileRegex True "[a-zA-Z]\\w*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\d+(\\.\\d+)?|\\.\\d+)([eE][+-]?\\d+)?[ij]?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(\\d+(\\.\\d+)?|\\.\\d+)([eE][+-]?\\d+)?[ij]?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "()[]{}"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "..."+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "=="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "~="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "!="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect ">="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<>"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "&&"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "||"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "++"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "--"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "**"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect ".*"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect ".**"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect ".^"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "./"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect ".'"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "!\"%(*+,/;=>[]|~#&)-:<>\\^"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Luis Silvestre and Federico Zenith"+  , sVersion = "2"+  , sLicense = "GPL"+  , sExtensions = [ "*.octave" , "*.m" , "*.M" ]+  , sStartingContext = "_normal"+  }
+ src/Skylighting/Syntax/Opencl.hs view
@@ -0,0 +1,1205 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Opencl (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "OpenCL"+  , sFilename = "opencl.xml"+  , sShortname = "Opencl"+  , sContexts =+      fromList+        [ ( "AfterHash"+          , Context+              { cName = "AfterHash"+              , cSyntax = "OpenCL"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*if(?:def|ndef)?(?=\\s+\\S)"+                              , reCompiled =+                                  Just (compileRegex False "#\\s*if(?:def|ndef)?(?=\\s+\\S)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "OpenCL" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*endif"+                              , reCompiled = Just (compileRegex False "#\\s*endif")+                              , reCaseSensitive = False+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "OpenCL" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*define.*((?=\\\\))"+                              , reCompiled = Just (compileRegex False "#\\s*define.*((?=\\\\))")+                              , reCaseSensitive = False+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "OpenCL" , "Define" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "#\\s*(?:el(?:se|if)|include(?:_next)?|define|undef|line|error|warning|pragma)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "#\\s*(?:el(?:se|if)|include(?:_next)?|define|undef|line|error|warning|pragma)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "OpenCL" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s+[0-9]+"+                              , reCompiled = Just (compileRegex False "#\\s+[0-9]+")+                              , reCaseSensitive = False+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "OpenCL" , "Preprocessor" ) ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Commentar 1"+          , Context+              { cName = "Commentar 1"+              , cSyntax = "OpenCL"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Commentar 2"+          , Context+              { cName = "Commentar 2"+              , cSyntax = "OpenCL"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Commentar/Preprocessor"+          , Context+              { cName = "Commentar/Preprocessor"+              , cSyntax = "OpenCL"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Define"+          , Context+              { cName = "Define"+              , cSyntax = "OpenCL"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "OpenCL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*if\\s+0\\s*$"+                              , reCompiled = Just (compileRegex True "#\\s*if\\s+0\\s*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "OpenCL" , "Outscoped" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "OpenCL" , "AfterHash" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "//BEGIN"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "OpenCL" , "Region Marker" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "//END"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "OpenCL" , "Region Marker" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "__constant"+                               , "__global"+                               , "__kernel"+                               , "__local"+                               , "__private"+                               , "__read_only"+                               , "__write_only"+                               , "break"+                               , "case"+                               , "constant"+                               , "continue"+                               , "default"+                               , "do"+                               , "else"+                               , "enum"+                               , "for"+                               , "global"+                               , "goto"+                               , "if"+                               , "inline"+                               , "kernel"+                               , "local"+                               , "private"+                               , "read_only"+                               , "return"+                               , "sizeof"+                               , "struct"+                               , "switch"+                               , "typedef"+                               , "union"+                               , "while"+                               , "write_only"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "bool"+                               , "char"+                               , "char16"+                               , "char2"+                               , "char3"+                               , "char4"+                               , "char8"+                               , "const"+                               , "double"+                               , "double16"+                               , "double2"+                               , "double3"+                               , "double4"+                               , "double8"+                               , "event_t"+                               , "float"+                               , "float16"+                               , "float2"+                               , "float3"+                               , "float4"+                               , "float8"+                               , "half"+                               , "half16"+                               , "half2"+                               , "half3"+                               , "half4"+                               , "half8"+                               , "image1d_t"+                               , "image2d_t"+                               , "image3d_t"+                               , "int"+                               , "int16"+                               , "int2"+                               , "int3"+                               , "int4"+                               , "int8"+                               , "long"+                               , "long16"+                               , "long2"+                               , "long3"+                               , "long4"+                               , "long8"+                               , "restrict"+                               , "sampler_t"+                               , "short"+                               , "short16"+                               , "short2"+                               , "short3"+                               , "short4"+                               , "short8"+                               , "signed"+                               , "static"+                               , "uchar"+                               , "uchar16"+                               , "uchar2"+                               , "uchar3"+                               , "uchar4"+                               , "uchar8"+                               , "uint"+                               , "uint16"+                               , "uint2"+                               , "uint3"+                               , "uint4"+                               , "uint8"+                               , "ulong"+                               , "ulong16"+                               , "ulong2"+                               , "ulong3"+                               , "ulong4"+                               , "ulong8"+                               , "unsigned"+                               , "ushort"+                               , "ushort16"+                               , "ushort2"+                               , "ushort3"+                               , "ushort4"+                               , "ushort8"+                               , "void"+                               , "volatile"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren =+                          [ Rule+                              { rMatcher = AnyChar "fF"+                              , rAttribute = FloatTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = True+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren =+                          [ Rule+                              { rMatcher = StringDetect "ULL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LUL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LLU"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "UL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LU"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "U"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "L"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "OpenCL" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "OpenCL" , "Commentar 1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "OpenCL" , "Commentar 2" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar ":!%&()+,-/.*<=>?[]|~^;"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Outscoped"+          , Context+              { cName = "Outscoped"+              , cSyntax = "OpenCL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "OpenCL" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "OpenCL" , "Commentar 1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "OpenCL" , "Commentar 2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*if"+                              , reCompiled = Just (compileRegex True "#\\s*if")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "OpenCL" , "Outscoped intern" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*el(?:se|if)"+                              , reCompiled = Just (compileRegex True "#\\s*el(?:se|if)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*endif"+                              , reCompiled = Just (compileRegex True "#\\s*endif")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Outscoped intern"+          , Context+              { cName = "Outscoped intern"+              , cSyntax = "OpenCL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "OpenCL" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "OpenCL" , "Commentar 1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "OpenCL" , "Commentar 2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*if"+                              , reCompiled = Just (compileRegex True "#\\s*if")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "OpenCL" , "Outscoped intern" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*endif"+                              , reCompiled = Just (compileRegex True "#\\s*endif")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Preprocessor"+          , Context+              { cName = "Preprocessor"+              , cSyntax = "OpenCL"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = RangeDetect '"' '"'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = RangeDetect '<' '>'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "OpenCL" , "Commentar/Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "OpenCL" , "Commentar 1" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Region Marker"+          , Context+              { cName = "Region Marker"+              , cSyntax = "OpenCL"+              , cRules = []+              , cAttribute = RegionMarkerTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "OpenCL"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = ""+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.cl" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Pascal.hs view
@@ -0,0 +1,727 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Pascal (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Pascal"+  , sFilename = "pascal.xml"+  , sShortname = "Pascal"+  , sContexts =+      fromList+        [ ( "CharNum"+          , Context+              { cName = "CharNum"+              , cSyntax = "Pascal"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pascal" , "HexCharNum" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^0-9]"+                              , reCompiled = Just (compileRegex True "[^0-9]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment1"+          , Context+              { cName = "Comment1"+              , cSyntax = "Pascal"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet False [ "###" , "FIXME" , "NOTE" , "TODO" ])+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment2"+          , Context+              { cName = "Comment2"+              , cSyntax = "Pascal"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet False [ "###" , "FIXME" , "NOTE" , "TODO" ])+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' ')'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment3"+          , Context+              { cName = "Comment3"+              , cSyntax = "Pascal"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet False [ "###" , "FIXME" , "NOTE" , "TODO" ])+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Hex"+          , Context+              { cName = "Hex"+              , cSyntax = "Pascal"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^a-fA-F0-9]"+                              , reCompiled = Just (compileRegex True "[^a-fA-F0-9]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = BaseNTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "HexCharNum"+          , Context+              { cName = "HexCharNum"+              , cSyntax = "Pascal"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^a-fA-F0-9]"+                              , reCompiled = Just (compileRegex True "[^a-fA-F0-9]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = BaseNTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Pascal"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b(begin|case|record)(?=(\\{[^}]*(\\}|$)|\\(\\*.*(\\*\\)|$))*([\\s]|$|//))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "\\b(begin|case|record)(?=(\\{[^}]*(\\}|$)|\\(\\*.*(\\*\\)|$))*([\\s]|$|//))")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b((object|class)(?=(\\(.*\\))?(\\{[^}]*(\\}|$)|\\(\\*.*(\\*\\)|$))*;?([\\s]|$|//))|try(?=(\\{[^}]*(\\}|$)|\\(\\*.*(\\*\\)|$))*([\\s]|$|//)))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "\\b((object|class)(?=(\\(.*\\))?(\\{[^}]*(\\}|$)|\\(\\*.*(\\*\\)|$))*;?([\\s]|$|//))|try(?=(\\{[^}]*(\\}|$)|\\(\\*.*(\\*\\)|$))*([\\s]|$|//)))")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\bend(?=((\\{[^}]*(\\}|$)|\\(\\*.*(\\*\\)|$))*)([.;\\s]|$)|//|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "\\bend(?=((\\{[^}]*(\\}|$)|\\(\\*.*(\\*\\)|$))*)([.;\\s]|$)|//|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "and"+                               , "array"+                               , "asm"+                               , "at"+                               , "automated"+                               , "break"+                               , "case"+                               , "const"+                               , "continue"+                               , "dispinterface"+                               , "dispose"+                               , "div"+                               , "do"+                               , "downto"+                               , "else"+                               , "exit"+                               , "false"+                               , "file"+                               , "finalization"+                               , "for"+                               , "function"+                               , "goto"+                               , "if"+                               , "in"+                               , "initialization"+                               , "label"+                               , "library"+                               , "mod"+                               , "new"+                               , "nil"+                               , "not"+                               , "of"+                               , "operator"+                               , "or"+                               , "packed"+                               , "procedure"+                               , "program"+                               , "published"+                               , "record"+                               , "repeat"+                               , "resourcestring"+                               , "self"+                               , "set"+                               , "then"+                               , "to"+                               , "true"+                               , "type"+                               , "unit"+                               , "until"+                               , "uses"+                               , "var"+                               , "while"+                               , "with"+                               , "xor"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "abstract"+                               , "as"+                               , "bindable"+                               , "constructor"+                               , "destructor"+                               , "except"+                               , "export"+                               , "finally"+                               , "implementation"+                               , "import"+                               , "inherited"+                               , "inline"+                               , "interface"+                               , "is"+                               , "module"+                               , "on"+                               , "only"+                               , "otherwise"+                               , "override"+                               , "private"+                               , "property"+                               , "protected"+                               , "public"+                               , "qualified"+                               , "raise"+                               , "read"+                               , "restricted"+                               , "shl"+                               , "shr"+                               , "threadvar"+                               , "try"+                               , "virtual"+                               , "write"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "AnsiChar"+                               , "AnsiString"+                               , "Boolean"+                               , "Byte"+                               , "ByteBool"+                               , "Cardinal"+                               , "Char"+                               , "Comp"+                               , "Currency"+                               , "Double"+                               , "DWord"+                               , "Extended"+                               , "File"+                               , "Int64"+                               , "Integer"+                               , "LongBool"+                               , "LongInt"+                               , "LongWord"+                               , "Pointer"+                               , "QWord"+                               , "Real"+                               , "Real48"+                               , "ShortInt"+                               , "ShortString"+                               , "Single"+                               , "SmallInt"+                               , "String"+                               , "Text"+                               , "Variant"+                               , "WideChar"+                               , "WideString"+                               , "Word"+                               , "WordBool"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pascal" , "Hex" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pascal" , "CharNum" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pascal" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "(*$"+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pascal" , "Prep1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '{' '$'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pascal" , "Prep2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pascal" , "Comment1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '(' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pascal" , "Comment2" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pascal" , "Comment3" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Prep1"+          , Context+              { cName = "Prep1"+              , cSyntax = "Pascal"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' ')'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Prep2"+          , Context+              { cName = "Prep2"+              , cSyntax = "Pascal"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Pascal"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Unnamed people and Liu Sizhuang(oldherl@gmail.com)"+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.p" , "*.pas" , "*.pp" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Perl.hs view
@@ -0,0 +1,5443 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Perl (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Perl"+  , sFilename = "perl.xml"+  , sShortname = "Perl"+  , sContexts =+      fromList+        [ ( "Backticked"+          , Context+              { cName = "Backticked"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Perl" , "ipstring_internal" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "comment"+          , Context+              { cName = "comment"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "data_handle"+          , Context+              { cName = "data_handle"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\=(?:head[1-6]|over|back|item|for|begin|end|pod)\\s+.*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\=(?:head[1-6]|over|back|item|for|begin|end|pod)\\s+.*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Perl" , "pod" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "__END__"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "normal" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "end_handle"+          , Context+              { cName = "end_handle"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\=(?:head[1-6]|over|back|item|for|begin|end|pod)\\s*.*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\=(?:head[1-6]|over|back|item|for|begin|end|pod)\\s*.*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Perl" , "pod" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "__DATA__"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "data_handle" ) ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_here_document"+          , Context+              { cName = "find_here_document"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\w+)\\s*;?"+                              , reCompiled = Just (compileRegex True "(\\w+)\\s*;?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "here_document" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\"([^\"]+)\"\\s*;?"+                              , reCompiled = Just (compileRegex True "\\s*\"([^\"]+)\"\\s*;?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "here_document" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*`([^`]+)`\\s*;?"+                              , reCompiled = Just (compileRegex True "\\s*`([^`]+)`\\s*;?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "here_document" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*'([^']+)'\\s*;?"+                              , reCompiled = Just (compileRegex True "\\s*'([^']+)'\\s*;?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "here_document_dumb" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_pattern"+          , Context+              { cName = "find_pattern"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+#.*"+                              , reCompiled = Just (compileRegex True "\\s+#.*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "pattern_brace" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "pattern_paren" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "pattern_bracket" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "pattern_sq" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([^\\w\\s])"+                              , reCompiled = Just (compileRegex True "([^\\w\\s])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "pattern" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_qqx"+          , Context+              { cName = "find_qqx"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "ip_string_2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "ip_string_3" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "ip_string_4" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "ip_string_5" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([^a-zA-Z0-9_\\s[\\]{}()])"+                              , reCompiled =+                                  Just (compileRegex True "([^a-zA-Z0-9_\\s[\\]{}()])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "ip_string_6" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+#.*"+                              , reCompiled = Just (compileRegex True "\\s+#.*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_quoted"+          , Context+              { cName = "find_quoted"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "x\\s*(')"+                              , reCompiled = Just (compileRegex True "x\\s*(')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "string_6" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "qx"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "find_qqx" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar 'w'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "find_qw" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "string_2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "string_3" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "string_4" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "string_5" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([^a-zA-Z0-9_\\s[\\]{}()])"+                              , reCompiled =+                                  Just (compileRegex True "([^a-zA-Z0-9_\\s[\\]{}()])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "string_6" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+#.*"+                              , reCompiled = Just (compileRegex True "\\s+#.*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_qw"+          , Context+              { cName = "find_qw"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "quote_word_paren" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "quote_word_brace" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "quote_word_bracket" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([^a-zA-Z0-9_\\s[\\]{}()])"+                              , reCompiled =+                                  Just (compileRegex True "([^a-zA-Z0-9_\\s[\\]{}()])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "quote_word" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+#.*"+                              , reCompiled = Just (compileRegex True "\\s+#.*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_subst"+          , Context+              { cName = "find_subst"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+#.*"+                              , reCompiled = Just (compileRegex True "\\s+#.*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "subst_curlybrace_pattern" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "subst_paren_pattern" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "subst_bracket_pattern" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "subst_sq_pattern" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([^\\w\\s[\\]{}()])"+                              , reCompiled = Just (compileRegex True "([^\\w\\s[\\]{}()])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "subst_slash_pattern" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_variable"+          , Context+              { cName = "find_variable"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[0-9]+"+                              , reCompiled = Just (compileRegex True "\\$[0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "var_detect" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[@\\$](?:[\\+\\-_]\\B|ARGV\\b|INC\\b)"+                              , reCompiled =+                                  Just (compileRegex True "[@\\$](?:[\\+\\-_]\\B|ARGV\\b|INC\\b)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "var_detect" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[%\\$](?:INC\\b|ENV\\b|SIG\\b)"+                              , reCompiled =+                                  Just (compileRegex True "[%\\$](?:INC\\b|ENV\\b|SIG\\b)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "var_detect" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\$[\\$\\w_]"+                              , reCompiled = Just (compileRegex True "\\$\\$[\\$\\w_]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "var_detect" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[#_][\\w_]"+                              , reCompiled = Just (compileRegex True "\\$[#_][\\w_]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "var_detect" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$+::"+                              , reCompiled = Just (compileRegex True "\\$+::")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "var_detect" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[^a-zA-Z0-9\\s{][A-Z]?"+                              , reCompiled = Just (compileRegex True "\\$[^a-zA-Z0-9\\s{][A-Z]?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "var_detect" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\$@%]\\{[\\w_]+\\}"+                              , reCompiled = Just (compileRegex True "[\\$@%]\\{[\\w_]+\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "var_detect" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "$@%"+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "var_detect" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\*[a-zA-Z_]+"+                              , reCompiled = Just (compileRegex True "\\*[a-zA-Z_]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "var_detect" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\*[^a-zA-Z0-9\\s{][A-Z]?"+                              , reCompiled = Just (compileRegex True "\\*[^a-zA-Z0-9\\s{][A-Z]?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "$@%*"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "find_variable_unsafe"+          , Context+              { cName = "find_variable_unsafe"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[0-9]+"+                              , reCompiled = Just (compileRegex True "\\$[0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "var_detect_unsafe" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[@\\$](?:[\\+\\-_]\\B|ARGV\\b|INC\\b)"+                              , reCompiled =+                                  Just (compileRegex True "[@\\$](?:[\\+\\-_]\\B|ARGV\\b|INC\\b)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "var_detect_unsafe" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[%\\$](?:INC\\b|ENV\\b|SIG\\b)"+                              , reCompiled =+                                  Just (compileRegex True "[%\\$](?:INC\\b|ENV\\b|SIG\\b)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "var_detect_unsafe" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\$[\\$\\w_]"+                              , reCompiled = Just (compileRegex True "\\$\\$[\\$\\w_]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "var_detect_unsafe" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[#_][\\w_]"+                              , reCompiled = Just (compileRegex True "\\$[#_][\\w_]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "var_detect_unsafe" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$+::"+                              , reCompiled = Just (compileRegex True "\\$+::")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "var_detect_unsafe" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[^a-zA-Z0-9\\s{][A-Z]?"+                              , reCompiled = Just (compileRegex True "\\$[^a-zA-Z0-9\\s{][A-Z]?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\$@%]\\{[\\w_]+\\}"+                              , reCompiled = Just (compileRegex True "[\\$@%]\\{[\\w_]+\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "var_detect_unsafe" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\$@%]"+                              , reCompiled = Just (compileRegex True "[\\$@%]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "var_detect_unsafe" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\*\\w+"+                              , reCompiled = Just (compileRegex True "\\*\\w+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "var_detect_unsafe" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "$@%*"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "here_document"+          , Context+              { cName = "here_document"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\=\\s*<<\\s*[\"']?([A-Z0-9_\\-]+)[\"']?"+                              , reCompiled =+                                  Just+                                    (compileRegex True "\\=\\s*<<\\s*[\"']?([A-Z0-9_\\-]+)[\"']?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "here_document" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Perl" , "ipstring_internal" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "here_document_dumb"+          , Context+              { cName = "here_document_dumb"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1" , reCompiled = Nothing , reCaseSensitive = True }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "ip_string"+          , Context+              { cName = "ip_string"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Perl" , "ipstring_internal" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ip_string_2"+          , Context+              { cName = "ip_string_2"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = RangeDetect '(' ')'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Perl" , "ipstring_internal" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ip_string_3"+          , Context+              { cName = "ip_string_3"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = RangeDetect '{' '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Perl" , "ipstring_internal" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ip_string_4"+          , Context+              { cName = "ip_string_4"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = RangeDetect '[' ']'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Perl" , "ipstring_internal" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ip_string_5"+          , Context+              { cName = "ip_string_5"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = RangeDetect '<' '>'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Perl" , "ipstring_internal" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ip_string_6"+          , Context+              { cName = "ip_string_6"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '1'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Perl" , "ipstring_internal" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "ipstring_internal"+          , Context+              { cName = "ipstring_internal"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[UuLlEtnaefr]"+                              , reCompiled = Just (compileRegex True "\\\\[UuLlEtnaefr]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(?:[\\$@]\\S|%[\\w{])"+                              , reCompiled = Just (compileRegex True "(?:[\\$@]\\S|%[\\w{])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "find_variable_unsafe" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "normal"+          , Context+              { cName = "normal"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#!\\/.*"+                              , reCompiled = Just (compileRegex True "#!\\/.*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "__DATA__"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "data_handle" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "__END__"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bsub\\s+"+                              , reCompiled = Just (compileRegex True "\\bsub\\s+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "sub_name_def" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "BEGIN"+                               , "END"+                               , "__DATA__"+                               , "__END__"+                               , "__FILE__"+                               , "__LINE__"+                               , "__PACKAGE__"+                               , "break"+                               , "continue"+                               , "default"+                               , "do"+                               , "each"+                               , "else"+                               , "elsif"+                               , "for"+                               , "foreach"+                               , "given"+                               , "if"+                               , "last"+                               , "local"+                               , "my"+                               , "next"+                               , "our"+                               , "package"+                               , "return"+                               , "state"+                               , "sub"+                               , "unless"+                               , "until"+                               , "when"+                               , "while"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "!="+                               , "%"+                               , "&"+                               , "&&"+                               , "&&="+                               , "&="+                               , "*"+                               , "**="+                               , "*="+                               , "+"+                               , "+="+                               , ","+                               , "-"+                               , "-="+                               , "->"+                               , "."+                               , "//"+                               , "//="+                               , "/="+                               , "::"+                               , ";"+                               , "<"+                               , "<<"+                               , "="+                               , "=>"+                               , ">"+                               , ">>"+                               , "?="+                               , "\\"+                               , "^"+                               , "and"+                               , "cmp"+                               , "eq"+                               , "ge"+                               , "gt"+                               , "le"+                               , "lt"+                               , "ne"+                               , "not"+                               , "or"+                               , "|"+                               , "|="+                               , "||"+                               , "||="+                               , "~="+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "abs"+                               , "accept"+                               , "alarm"+                               , "atan2"+                               , "bind"+                               , "binmode"+                               , "bless"+                               , "caller"+                               , "chdir"+                               , "chmod"+                               , "chomp"+                               , "chop"+                               , "chown"+                               , "chr"+                               , "chroot"+                               , "close"+                               , "closedir"+                               , "connect"+                               , "cos"+                               , "crypt"+                               , "dbmclose"+                               , "dbmopen"+                               , "defined"+                               , "delete"+                               , "die"+                               , "dump"+                               , "endgrent"+                               , "endhostent"+                               , "endnetent"+                               , "endprotoent"+                               , "endpwent"+                               , "endservent"+                               , "eof"+                               , "eval"+                               , "exec"+                               , "exists"+                               , "exit"+                               , "exp"+                               , "fcntl"+                               , "fileno"+                               , "flock"+                               , "fork"+                               , "format"+                               , "formline"+                               , "getc"+                               , "getgrent"+                               , "getgrgid"+                               , "getgrnam"+                               , "gethostbyaddr"+                               , "gethostbyname"+                               , "gethostent"+                               , "getlogin"+                               , "getnetbyaddr"+                               , "getnetbyname"+                               , "getnetent"+                               , "getpeername"+                               , "getpgrp"+                               , "getppid"+                               , "getpriority"+                               , "getprotobyname"+                               , "getprotobynumber"+                               , "getprotoent"+                               , "getpwent"+                               , "getpwnam"+                               , "getpwuid"+                               , "getservbyname"+                               , "getservbyport"+                               , "getservent"+                               , "getsockname"+                               , "getsockopt"+                               , "glob"+                               , "gmtime"+                               , "goto"+                               , "grep"+                               , "hex"+                               , "import"+                               , "index"+                               , "int"+                               , "ioctl"+                               , "join"+                               , "keys"+                               , "kill"+                               , "last"+                               , "lc"+                               , "lcfirst"+                               , "length"+                               , "link"+                               , "listen"+                               , "localtime"+                               , "lock"+                               , "log"+                               , "lstat"+                               , "map"+                               , "mkdir"+                               , "msgctl"+                               , "msgget"+                               , "msgrcv"+                               , "msgsnd"+                               , "no"+                               , "oct"+                               , "open"+                               , "opendir"+                               , "ord"+                               , "pack"+                               , "package"+                               , "pipe"+                               , "pop"+                               , "pos"+                               , "print"+                               , "printf"+                               , "prototype"+                               , "push"+                               , "quotemeta"+                               , "rand"+                               , "read"+                               , "readdir"+                               , "readline"+                               , "readlink"+                               , "recv"+                               , "redo"+                               , "ref"+                               , "rename"+                               , "require"+                               , "reset"+                               , "return"+                               , "reverse"+                               , "rewinddir"+                               , "rindex"+                               , "rmdir"+                               , "scalar"+                               , "seek"+                               , "seekdir"+                               , "select"+                               , "semctl"+                               , "semget"+                               , "semop"+                               , "send"+                               , "setgrent"+                               , "sethostent"+                               , "setnetent"+                               , "setpgrp"+                               , "setpriority"+                               , "setprotoent"+                               , "setpwent"+                               , "setservent"+                               , "setsockopt"+                               , "shift"+                               , "shmctl"+                               , "shmget"+                               , "shmread"+                               , "shmwrite"+                               , "shutdown"+                               , "sin"+                               , "sleep"+                               , "socket"+                               , "socketpair"+                               , "sort"+                               , "splice"+                               , "split"+                               , "sprintf"+                               , "sqrt"+                               , "srand"+                               , "stat"+                               , "study"+                               , "sub"+                               , "substr"+                               , "symlink"+                               , "syscall"+                               , "sysread"+                               , "sysseek"+                               , "system"+                               , "syswrite"+                               , "tell"+                               , "telldir"+                               , "tie"+                               , "time"+                               , "times"+                               , "truncate"+                               , "uc"+                               , "ucfirst"+                               , "umask"+                               , "undef"+                               , "unlink"+                               , "unpack"+                               , "unshift"+                               , "untie"+                               , "use"+                               , "utime"+                               , "values"+                               , "vec"+                               , "wait"+                               , "waitpid"+                               , "wantarray"+                               , "warn"+                               , "write"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "bytes"+                               , "constant"+                               , "diagnostics"+                               , "english"+                               , "filetest"+                               , "integer"+                               , "less"+                               , "locale"+                               , "open"+                               , "sigtrap"+                               , "strict"+                               , "subs"+                               , "utf8"+                               , "vars"+                               , "warnings"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\=\\w+(\\s|$)"+                              , reCompiled = Just (compileRegex True "\\=\\w+(\\s|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Perl" , "pod" ) ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b\\-?0[xX]([0-9a-fA-F]|_[0-9a-fA-F])+"+                              , reCompiled =+                                  Just (compileRegex True "\\b\\-?0[xX]([0-9a-fA-F]|_[0-9a-fA-F])+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "slash_safe_escape" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b\\-?0[bB]([01]|_[01])+"+                              , reCompiled = Just (compileRegex True "\\b\\-?0[bB]([01]|_[01])+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "slash_safe_escape" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b\\-?0[1-7]([0-7]|_[0-7])*"+                              , reCompiled =+                                  Just (compileRegex True "\\b\\-?0[1-7]([0-7]|_[0-7])*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "slash_safe_escape" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b\\-?[0-9]([0-9]|_[0-9])*\\.[0-9]([0-9]|_[0-9])*([eE]\\-?[1-9]([0-9]|_[0-9])*(\\.[0-9]*)?)?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\b\\-?[0-9]([0-9]|_[0-9])*\\.[0-9]([0-9]|_[0-9])*([eE]\\-?[1-9]([0-9]|_[0-9])*(\\.[0-9]*)?)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "slash_safe_escape" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b\\-?[1-9]([0-9]|_[0-9])*\\b"+                              , reCompiled =+                                  Just (compileRegex True "\\b\\-?[1-9]([0-9]|_[0-9])*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "slash_safe_escape" ) ]+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "slash_safe_escape" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\([\"'])[^\\1]"+                              , reCompiled = Just (compileRegex True "\\\\([\"'])[^\\1]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '&' '\''+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "ip_string" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "string" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "Backticked" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(?:[$@]\\S|%[\\w{]|\\*[^\\d\\*{\\$@%=(])"+                              , reCompiled =+                                  Just+                                    (compileRegex True "(?:[$@]\\S|%[\\w{]|\\*[^\\d\\*{\\$@%=(])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "find_variable" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<[A-Z0-9_]+>"+                              , reCompiled = Just (compileRegex True "<[A-Z0-9_]+>")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*<<(?=\\w+|\\s*[\"'])"+                              , reCompiled = Just (compileRegex True "\\s*<<(?=\\w+|\\s*[\"'])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "find_here_document" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\}\\s*/{1,2}"+                              , reCompiled = Just (compileRegex True "\\s*\\}\\s*/{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*[)\\]]\\s*/{1,2}"+                              , reCompiled = Just (compileRegex True "\\s*[)\\]]\\s*/{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\w+::"+                              , reCompiled = Just (compileRegex True "\\w+::")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "sub_name_def" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\w+[=]"+                              , reCompiled = Just (compileRegex True "\\w+[=]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bq(?=[qwx]?\\s*[^\\w\\s])"+                              , reCompiled =+                                  Just (compileRegex True "\\bq(?=[qwx]?\\s*[^\\w\\s])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "find_quoted" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bs(?=\\s*[^\\w\\s\\]})])"+                              , reCompiled =+                                  Just (compileRegex True "\\bs(?=\\s*[^\\w\\s\\]})])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "find_subst" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(?:tr|y)\\s*(?=[^\\w\\s\\]})])"+                              , reCompiled =+                                  Just (compileRegex True "\\b(?:tr|y)\\s*(?=[^\\w\\s\\]})])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "tr" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(?:m|qr)(?=\\s*[^\\w\\s\\]})])"+                              , reCompiled =+                                  Just (compileRegex True "\\b(?:m|qr)(?=\\s*[^\\w\\s\\]})])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "find_pattern" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\w_]+\\s*/"+                              , reCompiled = Just (compileRegex True "[\\w_]+\\s*/")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[<>\"':]/"+                              , reCompiled = Just (compileRegex True "[<>\"':]/")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '/'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "pattern_slash" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-[rwxoRWXOeszfdlpSbctugkTBMAC]\\b"+                              , reCompiled =+                                  Just (compileRegex True "-[rwxoRWXOeszfdlpSbctugkTBMAC]\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "package_qualified_blank"+          , Context+              { cName = "package_qualified_blank"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\w_]+"+                              , reCompiled = Just (compileRegex True "[\\w_]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "pat_char_class"+          , Context+              { cName = "pat_char_class"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '^'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ']'+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[:\\^?[a-z]+:\\]"+                              , reCompiled = Just (compileRegex True "\\[:\\^?[a-z]+:\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = BaseNTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "pat_ext"+          , Context+              { cName = "pat_ext"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\#[^)]*"+                              , reCompiled = Just (compileRegex True "\\#[^)]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[:=!><]+"+                              , reCompiled = Just (compileRegex True "[:=!><]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CharTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "pattern"+          , Context+              { cName = "pattern"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$(?=%1)"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1[cgimosx]*"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Perl" , "regex_pattern_internal_ip" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$(?=\\%1)"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "pattern_brace"+          , Context+              { cName = "pattern_brace"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\}[cgimosx]*"+                              , reCompiled = Just (compileRegex True "\\}[cgimosx]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Perl" , "regex_pattern_internal_ip" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "pattern_bracket"+          , Context+              { cName = "pattern_bracket"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\][cgimosx]*"+                              , reCompiled = Just (compileRegex True "\\][cgimosx]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Perl" , "regex_pattern_internal_ip" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "pattern_paren"+          , Context+              { cName = "pattern_paren"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\)[cgimosx]*"+                              , reCompiled = Just (compileRegex True "\\)[cgimosx]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Perl" , "regex_pattern_internal_ip" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "pattern_slash"+          , Context+              { cName = "pattern_slash"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$(?=/)"+                              , reCompiled = Just (compileRegex True "\\$(?=/)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Perl" , "regex_pattern_internal_ip" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/[cgimosx]*"+                              , reCompiled = Just (compileRegex True "/[cgimosx]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "pattern_sq"+          , Context+              { cName = "pattern_sq"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'[cgimosx]*"+                              , reCompiled = Just (compileRegex True "'[cgimosx]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Perl" , "regex_pattern_internal" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "pod"+          , Context+              { cName = "pod"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\=(?:head[1-6]|over|back|item|for|begin|end|pod)\\s*.*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\=(?:head[1-6]|over|back|item|for|begin|end|pod)\\s*.*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\=cut.*$"+                              , reCompiled = Just (compileRegex True "\\=cut.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "quote_word"+          , Context+              { cName = "quote_word"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '1'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "quote_word_brace"+          , Context+              { cName = "quote_word_brace"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "quote_word_bracket"+          , Context+              { cName = "quote_word_bracket"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ']'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "quote_word_paren"+          , Context+              { cName = "quote_word_paren"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "regex_pattern_internal"+          , Context+              { cName = "regex_pattern_internal"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Perl" , "regex_pattern_internal_rules_1" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Perl" , "regex_pattern_internal_rules_2" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "regex_pattern_internal_ip"+          , Context+              { cName = "regex_pattern_internal_ip"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Perl" , "regex_pattern_internal_rules_1" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[$@][^]\\s{}()|>']"+                              , reCompiled = Just (compileRegex True "[$@][^]\\s{}()|>']")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "find_variable_unsafe" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Perl" , "regex_pattern_internal_rules_2" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "regex_pattern_internal_rules_1"+          , Context+              { cName = "regex_pattern_internal_rules_1"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#.*$"+                              , reCompiled = Just (compileRegex True "#.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[anDdSsWw]"+                              , reCompiled = Just (compileRegex True "\\\\[anDdSsWw]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[ABbEGLlNUuQdQZz]"+                              , reCompiled = Just (compileRegex True "\\\\[ABbEGLlNUuQdQZz]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[\\d]+"+                              , reCompiled = Just (compileRegex True "\\\\[\\d]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "regex_pattern_internal_rules_2"+          , Context+              { cName = "regex_pattern_internal_rules_2"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '(' '?'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "pat_ext" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "pat_char_class" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[()?^*+|]"+                              , reCompiled = Just (compileRegex True "[()?^*+|]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{[\\d, ]+\\}"+                              , reCompiled = Just (compileRegex True "\\{[\\d, ]+\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s{3,}#.*$"+                              , reCompiled = Just (compileRegex True "\\s{3,}#.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "slash_safe_escape"+          , Context+              { cName = "slash_safe_escape"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\}\\s*/{1,2}"+                              , reCompiled = Just (compileRegex True "\\s*\\}\\s*/{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*[)\\]]?\\s*/{1,2}"+                              , reCompiled = Just (compileRegex True "\\s*[)\\]]?\\s*/{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "BEGIN"+                               , "END"+                               , "__DATA__"+                               , "__END__"+                               , "__FILE__"+                               , "__LINE__"+                               , "__PACKAGE__"+                               , "break"+                               , "continue"+                               , "default"+                               , "do"+                               , "each"+                               , "else"+                               , "elsif"+                               , "for"+                               , "foreach"+                               , "given"+                               , "if"+                               , "last"+                               , "local"+                               , "my"+                               , "next"+                               , "our"+                               , "package"+                               , "return"+                               , "state"+                               , "sub"+                               , "unless"+                               , "until"+                               , "when"+                               , "while"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "string"+          , Context+              { cName = "string"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "string_2"+          , Context+              { cName = "string_2"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ')'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = RangeDetect '(' ')'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "string_3"+          , Context+              { cName = "string_3"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '}'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = RangeDetect '{' '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "string_4"+          , Context+              { cName = "string_4"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ']'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = RangeDetect '[' ']'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "string_5"+          , Context+              { cName = "string_5"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '<'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '>'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = RangeDetect '<' '>'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "string_6"+          , Context+              { cName = "string_6"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '1'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "sub_arg_definition"+          , Context+              { cName = "sub_arg_definition"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = AnyChar "*$@%"+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "&\\[];"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "slash_safe_escape" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop , Pop ]+              , cDynamic = False+              }+          )+        , ( "sub_name_def"+          , Context+              { cName = "sub_name_def"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\w+"+                              , reCompiled = Just (compileRegex True "\\w+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\S"+                              , reCompiled = Just (compileRegex True "\\$\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "find_variable" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\("+                              , reCompiled = Just (compileRegex True "\\s*\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "sub_arg_definition" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars ':' ':'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "subst_bracket_pattern"+          , Context+              { cName = "subst_bracket_pattern"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+#.*$"+                              , reCompiled = Just (compileRegex True "\\s+#.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Perl" , "regex_pattern_internal_ip" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "subst_bracket_replace" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "subst_bracket_replace"+          , Context+              { cName = "subst_bracket_replace"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Perl" , "ipstring_internal" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\][cegimosx]*"+                              , reCompiled = Just (compileRegex True "\\][cegimosx]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "subst_curlybrace_middle"+          , Context+              { cName = "subst_curlybrace_middle"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#.*$"+                              , reCompiled = Just (compileRegex True "#.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "subst_curlybrace_replace" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "subst_curlybrace_pattern"+          , Context+              { cName = "subst_curlybrace_pattern"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+#.*$"+                              , reCompiled = Just (compileRegex True "\\s+#.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Perl" , "regex_pattern_internal_ip" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "subst_curlybrace_middle" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "subst_curlybrace_replace"+          , Context+              { cName = "subst_curlybrace_replace"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Perl" , "ipstring_internal" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Perl" , "subst_curlybrace_replace_recursive" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\}[cegimosx]*"+                              , reCompiled = Just (compileRegex True "\\}[cegimosx]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "subst_curlybrace_replace_recursive"+          , Context+              { cName = "subst_curlybrace_replace_recursive"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Perl" , "subst_curlybrace_replace_recursive" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Perl" , "ipstring_internal" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "subst_paren_pattern"+          , Context+              { cName = "subst_paren_pattern"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+#.*$"+                              , reCompiled = Just (compileRegex True "\\s+#.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Perl" , "regex_pattern_internal_ip" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "subst_paren_replace" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "subst_paren_replace"+          , Context+              { cName = "subst_paren_replace"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Perl" , "ipstring_internal" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\)[cegimosx]*"+                              , reCompiled = Just (compileRegex True "\\)[cegimosx]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "subst_slash_pattern"+          , Context+              { cName = "subst_slash_pattern"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$(?=%1)"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(%1)"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "subst_slash_replace" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Perl" , "regex_pattern_internal_ip" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "subst_slash_replace"+          , Context+              { cName = "subst_slash_replace"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1[cegimosx]*"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Perl" , "ipstring_internal" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "subst_sq_pattern"+          , Context+              { cName = "subst_sq_pattern"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+#.*$"+                              , reCompiled = Just (compileRegex True "\\s+#.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Perl" , "regex_pattern_internal" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Perl" , "subst_sq_replace" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "subst_sq_replace"+          , Context+              { cName = "subst_sq_replace"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'[cegimosx]*"+                              , reCompiled = Just (compileRegex True "'[cegimosx]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "tr"+          , Context+              { cName = "tr"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\([^)]*\\)\\s*\\(?:[^)]*\\)"+                              , reCompiled =+                                  Just (compileRegex True "\\([^)]*\\)\\s*\\(?:[^)]*\\)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{[^}]*\\}\\s*\\{[^}]*\\}"+                              , reCompiled =+                                  Just (compileRegex True "\\{[^}]*\\}\\s*\\{[^}]*\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[[^]]*\\]\\s*\\[[^\\]]*\\]"+                              , reCompiled =+                                  Just (compileRegex True "\\[[^]]*\\]\\s*\\[[^\\]]*\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([^a-zA-Z0-9_\\s[\\]{}()]).*\\1.*\\1"+                              , reCompiled =+                                  Just (compileRegex True "([^a-zA-Z0-9_\\s[\\]{}()]).*\\1.*\\1")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "var_detect"+          , Context+              { cName = "var_detect"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Perl" , "var_detect_rules" )+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Perl" , "slash_safe_escape" )+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop , Pop ]+              , cDynamic = False+              }+          )+        , ( "var_detect_rules"+          , Context+              { cName = "var_detect_rules"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\w_]+"+                              , reCompiled = Just (compileRegex True "[\\w_]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars ':' ':'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '-' '>'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '+' '+'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '-' '-'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "var_detect_unsafe"+          , Context+              { cName = "var_detect_unsafe"+              , cSyntax = "Perl"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Perl" , "var_detect_rules" )+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop , Pop ]+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Anders Lund (anders@alweb.dk)"+  , sVersion = "3"+  , sLicense = "LGPLv2"+  , sExtensions = [ "*.pl" , "*.PL" , "*.pm" ]+  , sStartingContext = "normal"+  }
+ src/Skylighting/Syntax/Php.hs view
@@ -0,0 +1,7388 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Php (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "PHP/PHP"+  , sFilename = "php.xml"+  , sShortname = "Php"+  , sContexts =+      fromList+        [ ( "backquotestring"+          , Context+              { cName = "backquotestring"+              , cSyntax = "PHP/PHP"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "PHP/PHP" , "doublebackquotestringcommon" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '`'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "case"+          , Context+              { cName = "case"+              , cSyntax = "PHP/PHP"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "PHP/PHP" , "ternary" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "commonheredoc"+          , Context+              { cName = "commonheredoc"+              , cSyntax = "PHP/PHP"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\$[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*(\\[[a-zA-Z0-9_]*\\])*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\$[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*(\\[[a-zA-Z0-9_]*\\])*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\$\\{[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*(\\[[a-zA-Z0-9_]*\\])*\\}"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\$\\{[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*(\\[[a-zA-Z0-9_]*\\])*\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\{\\$[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*(\\[([0-9]*|\"[a-zA-Z_]*\")|'[a-zA-Z_]*'|\\])*(->[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*(\\[[a-zA-Z0-9_]*\\])*(\\[([0-9]*|\"[a-zA-Z_]*\")|'[a-zA-Z_]*'|\\])*)*\\}"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\{\\$[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*(\\[([0-9]*|\"[a-zA-Z_]*\")|'[a-zA-Z_]*'|\\])*(->[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*(\\[[a-zA-Z0-9_]*\\])*(\\[([0-9]*|\"[a-zA-Z_]*\")|'[a-zA-Z_]*'|\\])*)*\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "commonnowdoc"+          , Context+              { cName = "commonnowdoc"+              , cSyntax = "PHP/PHP"+              , cRules = []+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "cssheredoc"+          , Context+              { cName = "cssheredoc"+              , cSyntax = "PHP/PHP"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1;?$"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "PHP/PHP" , "commonheredoc" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "cssnowdoc"+          , Context+              { cName = "cssnowdoc"+              , cSyntax = "PHP/PHP"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1;?$"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "PHP/PHP" , "commonnowdoc" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "doublebackquotestringcommon"+          , Context+              { cName = "doublebackquotestringcommon"+              , cSyntax = "PHP/PHP"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' 'n'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' 'r'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' 't'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' 'v'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' 'f'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '$'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[0-7]{1,3}"+                              , reCompiled = Just (compileRegex True "\\\\[0-7]{1,3}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\x[0-9A-Fa-f]{1,2}"+                              , reCompiled = Just (compileRegex True "\\\\x[0-9A-Fa-f]{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\$[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*(\\[[a-zA-Z0-9_]*\\])*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\$[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*(\\[[a-zA-Z0-9_]*\\])*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\$\\{[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*(\\[[a-zA-Z0-9_]*\\])*\\}"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\$\\{[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*(\\[[a-zA-Z0-9_]*\\])*\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\{\\$[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*(\\[([0-9]*|\"[^\"]*\"|\\$[a-zA-Z]*)|'[^']*'|\\])*(->[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*(\\[[a-zA-Z0-9_]*\\])*(\\[([0-9]*|\"[a-zA-Z_]*\")|'[a-zA-Z_]*'|\\])*)*\\}"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\{\\$[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*(\\[([0-9]*|\"[^\"]*\"|\\$[a-zA-Z]*)|'[^']*'|\\])*(->[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*(\\[[a-zA-Z0-9_]*\\])*(\\[([0-9]*|\"[a-zA-Z_]*\")|'[a-zA-Z_]*'|\\])*)*\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "doublequotestring"+          , Context+              { cName = "doublequotestring"+              , cSyntax = "PHP/PHP"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "PHP/PHP" , "doublebackquotestringcommon" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '"'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "heredoc"+          , Context+              { cName = "heredoc"+              , cSyntax = "PHP/PHP"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1;?$"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "PHP/PHP" , "commonheredoc" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "htmlheredoc"+          , Context+              { cName = "htmlheredoc"+              , cSyntax = "PHP/PHP"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1;?$"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "PHP/PHP" , "commonheredoc" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "HTML" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "htmlnowdoc"+          , Context+              { cName = "htmlnowdoc"+              , cSyntax = "PHP/PHP"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1;?$"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "PHP/PHP" , "commonnowdoc" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "HTML" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "javascriptheredoc"+          , Context+              { cName = "javascriptheredoc"+              , cSyntax = "PHP/PHP"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1;?$"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "PHP/PHP" , "commonheredoc" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "JavaScript" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "javascriptnowdoc"+          , Context+              { cName = "javascriptnowdoc"+              , cSyntax = "PHP/PHP"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1;?$"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "PHP/PHP" , "commonnowdoc" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "JavaScript" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "mysqlheredoc"+          , Context+              { cName = "mysqlheredoc"+              , cSyntax = "PHP/PHP"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1;?$"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "PHP/PHP" , "commonheredoc" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "SQL (MySQL)" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "mysqlnowdoc"+          , Context+              { cName = "mysqlnowdoc"+              , cSyntax = "PHP/PHP"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1;?$"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "PHP/PHP" , "commonnowdoc" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "SQL (MySQL)" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "nowdoc"+          , Context+              { cName = "nowdoc"+              , cSyntax = "PHP/PHP"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1;?$"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "PHP/PHP" , "commonnowdoc" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "onelinecomment"+          , Context+              { cName = "onelinecomment"+              , cSyntax = "PHP/PHP"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "?>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "phpsource"+          , Context+              { cName = "phpsource"+              , cSyntax = "PHP/PHP"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "?>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '?'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "ternary" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(case|default)(\\s|:|$)"+                              , reCompiled = Just (compileRegex True "(case|default)(\\s|:|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "case" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars ':' ':'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "endif|endwhile|endfor|endforeach|endswitch"+                              , reCompiled =+                                  Just+                                    (compileRegex True "endif|endwhile|endfor|endforeach|endswitch")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "onelinecomment" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Doxygen" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "onelinecomment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "twolinecomment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?@[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "$DOCUMENT_ROOT"+                               , "$HTTP_COOKIE_VARS"+                               , "$HTTP_ENV_VARS"+                               , "$HTTP_GET_VARS"+                               , "$HTTP_POST_FILES"+                               , "$HTTP_POST_VARS"+                               , "$HTTP_SERVER_VARS"+                               , "$HTTP_SESSION_VARS"+                               , "call_user_method"+                               , "call_user_method_array"+                               , "ereg"+                               , "ereg_replace"+                               , "eregi"+                               , "eregi_replace"+                               , "mcrypt_ecb"+                               , "mime_content_type"+                               , "mysql_create_db"+                               , "mysql_dbname"+                               , "mysql_drop_db"+                               , "mysql_fieldflags"+                               , "mysql_fieldlen"+                               , "mysql_fieldname"+                               , "mysql_fieldtable"+                               , "mysql_fieldtype"+                               , "mysql_freeresult"+                               , "mysql_list_fields"+                               , "mysql_list_tables"+                               , "mysql_listdbs"+                               , "mysql_listfields"+                               , "mysql_listtables"+                               , "mysql_numfields"+                               , "mysql_numrows"+                               , "mysql_selectdb"+                               , "mysql_tablename"+                               , "mysqli_disable_reads_from_master"+                               , "mysqli_disable_rpl_parse"+                               , "mysqli_enable_reads_from_master"+                               , "mysqli_enable_rpl_parse"+                               , "mysqli_master_query"+                               , "mysqli_rpl_parse_enabled"+                               , "mysqli_rpl_probe"+                               , "mysqli_rpl_query_type"+                               , "mysqli_send_query"+                               , "mysqli_slave_query"+                               , "OCI_D_FILE"+                               , "OCI_D_LOB"+                               , "OCI_D_ROWID"+                               , "OCI_DEFAULT"+                               , "OCI_EXACT_FETCH"+                               , "OCI_SYSDATE"+                               , "ocifetchinto"+                               , "ora_bind"+                               , "ora_close"+                               , "ora_columnname"+                               , "ora_columnsize"+                               , "ora_columntype"+                               , "ora_commit"+                               , "ora_commitoff"+                               , "ora_commiton"+                               , "ora_do"+                               , "ora_error"+                               , "ora_errorcode"+                               , "ora_exec"+                               , "ora_fetch"+                               , "ora_fetch_into"+                               , "ora_getcolumn"+                               , "ora_logoff"+                               , "ora_logon"+                               , "ora_numcols"+                               , "ora_numrows"+                               , "ora_open"+                               , "ora_parse"+                               , "ora_plogon"+                               , "ora_rollback"+                               , "php_check_syntax"+                               , "split"+                               , "spliti"+                               , "sql_regcase"+                               , "var"+                               ])+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?@[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "as"+                               , "break"+                               , "case"+                               , "continue"+                               , "declare"+                               , "default"+                               , "do"+                               , "else"+                               , "elseif"+                               , "endfor"+                               , "endforeach"+                               , "endif"+                               , "endswitch"+                               , "endwhile"+                               , "for"+                               , "foreach"+                               , "if"+                               , "include"+                               , "include_once"+                               , "require"+                               , "require_once"+                               , "return"+                               , "switch"+                               , "while"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?@[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "abstract"+                               , "and"+                               , "callable"+                               , "catch"+                               , "class"+                               , "clone"+                               , "const"+                               , "exception"+                               , "extends"+                               , "final"+                               , "finally"+                               , "function"+                               , "global"+                               , "implements"+                               , "instanceof"+                               , "insteadof"+                               , "interface"+                               , "namespace"+                               , "new"+                               , "or"+                               , "parent"+                               , "private"+                               , "protected"+                               , "public"+                               , "self"+                               , "static"+                               , "throw"+                               , "trait"+                               , "try"+                               , "use"+                               , "var"+                               , "xor"+                               , "yield"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?@[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "__PHP_Incomplete_Class"+                               , "APCIterator"+                               , "AppendIterator"+                               , "ArrayAccess"+                               , "ArrayIterator"+                               , "ArrayObject"+                               , "BadFunctionCallException"+                               , "BadMethodCallException"+                               , "CachingIterator"+                               , "Closure"+                               , "Countable"+                               , "DateInterval"+                               , "DatePeriod"+                               , "DateTime"+                               , "DateTimeZone"+                               , "Directory"+                               , "DirectoryIterator"+                               , "DomainException"+                               , "DOMAttr"+                               , "DOMCDATASection"+                               , "DOMCharacterData"+                               , "DOMComment"+                               , "DOMConfiguration"+                               , "DOMDocument"+                               , "DOMDocumentFragment"+                               , "DOMDocumentType"+                               , "DOMDomError"+                               , "DOMElement"+                               , "DOMEntity"+                               , "DOMEntityReference"+                               , "DOMErrorHandler"+                               , "DOMException"+                               , "DOMImplementation"+                               , "DOMImplementationList"+                               , "DOMImplementationSource"+                               , "DOMLocator"+                               , "DOMNamedNodeMap"+                               , "DOMNameList"+                               , "DOMNameSpaceNode"+                               , "DOMNode"+                               , "DOMNodeList"+                               , "DOMNotation"+                               , "DOMProcessingInstruction"+                               , "DOMStringExtend"+                               , "DOMStringList"+                               , "DOMText"+                               , "DOMTypeinfo"+                               , "DOMUserDataHandler"+                               , "DOMXPath"+                               , "EmptyIterator"+                               , "ErrorException"+                               , "Exception"+                               , "FilesystemIterator"+                               , "FilterIterator"+                               , "GlobIterator"+                               , "InfiniteIterator"+                               , "InvalidArgumentException"+                               , "Iterator"+                               , "IteratorAggregate"+                               , "IteratorIterator"+                               , "LengthException"+                               , "LibXMLError"+                               , "LimitIterator"+                               , "LogicException"+                               , "MultipleIterator"+                               , "MySQLi"+                               , "MySQLi_Driver"+                               , "MySQLi_Result"+                               , "MySQLi_SQL_Exception"+                               , "MySQLi_STMT"+                               , "MySQLi_Warning"+                               , "NoRewindIterator"+                               , "OCI-Collection"+                               , "OCI-LOB"+                               , "OuterIterator"+                               , "OutOfBoundsException"+                               , "OutOfRangeException"+                               , "OverflowException"+                               , "ParentIterator"+                               , "PDO"+                               , "PDOException"+                               , "PDORow"+                               , "PDOStatement"+                               , "Phar"+                               , "PharData"+                               , "PharException"+                               , "PharFileInfo"+                               , "php_user_filter"+                               , "RangeException"+                               , "RecursiveArrayIterator"+                               , "RecursiveCachingIterator"+                               , "RecursiveDirectoryIterator"+                               , "RecursiveFilterIterator"+                               , "RecursiveIterator"+                               , "RecursiveIteratorIterator"+                               , "RecursiveRegexIterator"+                               , "RecursiveTreeIterator"+                               , "Reflection"+                               , "ReflectionClass"+                               , "ReflectionException"+                               , "ReflectionExtension"+                               , "ReflectionFunction"+                               , "ReflectionFunctionAbstract"+                               , "ReflectionMethod"+                               , "ReflectionObject"+                               , "ReflectionParameter"+                               , "ReflectionProperty"+                               , "Reflector"+                               , "RegexIterator"+                               , "RuntimeException"+                               , "SeekableIterator"+                               , "Serializable"+                               , "SimpleXMLElement"+                               , "SimpleXMLIterator"+                               , "SplDoublyLinkedList"+                               , "SplFileInfo"+                               , "SplFileObject"+                               , "SplFixedArray"+                               , "SplHeap"+                               , "SplMaxHeap"+                               , "SplMinHeap"+                               , "SplObjectStorage"+                               , "SplObserver"+                               , "SplPriorityQueue"+                               , "SplQueue"+                               , "SplStack"+                               , "SplSubject"+                               , "SplTempFileObject"+                               , "SQLite3"+                               , "SQLite3Result"+                               , "SQLite3Stmt"+                               , "SQLiteDatabase"+                               , "SQLiteException"+                               , "SQLiteResult"+                               , "SQLiteUnbuffered"+                               , "stdClass"+                               , "Traversable"+                               , "UnderflowException"+                               , "UnexpectedValueException"+                               , "XMLReader"+                               , "XMLWriter"+                               , "XSLTProcessor"+                               , "ZipArchive"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '@'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?@[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "_"+                               , "abs"+                               , "acos"+                               , "acosh"+                               , "addcslashes"+                               , "addslashes"+                               , "apache_get_modules"+                               , "apache_get_version"+                               , "apache_getenv"+                               , "apache_lookup_uri"+                               , "apache_note"+                               , "apache_request_headers"+                               , "apache_response_headers"+                               , "apache_setenv"+                               , "array"+                               , "array_change_key_case"+                               , "array_chunk"+                               , "array_combine"+                               , "array_count_values"+                               , "array_diff"+                               , "array_diff_assoc"+                               , "array_diff_key"+                               , "array_diff_uassoc"+                               , "array_diff_ukey"+                               , "array_fill"+                               , "array_fill_keys"+                               , "array_filter"+                               , "array_flip"+                               , "array_intersect"+                               , "array_intersect_assoc"+                               , "array_intersect_key"+                               , "array_intersect_uassoc"+                               , "array_intersect_ukey"+                               , "array_key_exists"+                               , "array_keys"+                               , "array_map"+                               , "array_merge"+                               , "array_merge_recursive"+                               , "array_multisort"+                               , "array_pad"+                               , "array_pop"+                               , "array_product"+                               , "array_push"+                               , "array_rand"+                               , "array_reduce"+                               , "array_replace"+                               , "array_replace_recursive"+                               , "array_reverse"+                               , "array_search"+                               , "array_shift"+                               , "array_slice"+                               , "array_splice"+                               , "array_sum"+                               , "array_udiff"+                               , "array_udiff_assoc"+                               , "array_udiff_uassoc"+                               , "array_uintersect"+                               , "array_uintersect_assoc"+                               , "array_uintersect_uassoc"+                               , "array_unique"+                               , "array_unshift"+                               , "array_values"+                               , "array_walk"+                               , "array_walk_recursive"+                               , "arsort"+                               , "ascii2ebcdic"+                               , "asin"+                               , "asinh"+                               , "asort"+                               , "aspell_check"+                               , "aspell_check_raw"+                               , "aspell_new"+                               , "aspell_suggest"+                               , "assert"+                               , "assert_options"+                               , "atan"+                               , "atan2"+                               , "atanh"+                               , "base64_decode"+                               , "base64_encode"+                               , "base_convert"+                               , "basename"+                               , "bcadd"+                               , "bccomp"+                               , "bcdiv"+                               , "bcmod"+                               , "bcmul"+                               , "bcpow"+                               , "bcpowmod"+                               , "bcscale"+                               , "bcsqrt"+                               , "bcsub"+                               , "bin2hex"+                               , "bind_textdomain_codeset"+                               , "bindec"+                               , "bindtextdomain"+                               , "bzclose"+                               , "bzcompress"+                               , "bzdecompress"+                               , "bzerrno"+                               , "bzerror"+                               , "bzerrstr"+                               , "bzflush"+                               , "bzopen"+                               , "bzread"+                               , "bzwrite"+                               , "cal_days_in_month"+                               , "cal_from_jd"+                               , "cal_info"+                               , "cal_to_jd"+                               , "call_user_func"+                               , "call_user_func_array"+                               , "ccvs_add"+                               , "ccvs_auth"+                               , "ccvs_command"+                               , "ccvs_count"+                               , "ccvs_delete"+                               , "ccvs_done"+                               , "ccvs_init"+                               , "ccvs_lookup"+                               , "ccvs_new"+                               , "ccvs_report"+                               , "ccvs_return"+                               , "ccvs_reverse"+                               , "ccvs_sale"+                               , "ccvs_status"+                               , "ccvs_textvalue"+                               , "ccvs_void"+                               , "ceil"+                               , "chdir"+                               , "checkdate"+                               , "checkdnsrr"+                               , "chgrp"+                               , "chmod"+                               , "chop"+                               , "chown"+                               , "chr"+                               , "chroot"+                               , "chunk_split"+                               , "class_exists"+                               , "class_implements"+                               , "class_parents"+                               , "clearstatcache"+                               , "closedir"+                               , "closelog"+                               , "com"+                               , "com_addref"+                               , "com_get"+                               , "com_invoke"+                               , "com_isenum"+                               , "com_load"+                               , "com_load_typelib"+                               , "com_propget"+                               , "com_propput"+                               , "com_propset"+                               , "com_release"+                               , "com_set"+                               , "compact"+                               , "connection_aborted"+                               , "connection_status"+                               , "connection_timeout"+                               , "constant"+                               , "convert_cyr_string"+                               , "convert_uudecode"+                               , "convert_uuencode"+                               , "copy"+                               , "cos"+                               , "cosh"+                               , "count"+                               , "count_chars"+                               , "cpdf_add_annotation"+                               , "cpdf_add_outline"+                               , "cpdf_arc"+                               , "cpdf_begin_text"+                               , "cpdf_circle"+                               , "cpdf_clip"+                               , "cpdf_close"+                               , "cpdf_closepath"+                               , "cpdf_closepath_fill_stroke"+                               , "cpdf_closepath_stroke"+                               , "cpdf_continue_text"+                               , "cpdf_curveto"+                               , "cpdf_end_text"+                               , "cpdf_fill"+                               , "cpdf_fill_stroke"+                               , "cpdf_finalize"+                               , "cpdf_finalize_page"+                               , "cpdf_global_set_document_limits"+                               , "cpdf_import_jpeg"+                               , "cpdf_lineto"+                               , "cpdf_moveto"+                               , "cpdf_newpath"+                               , "cpdf_open"+                               , "cpdf_output_buffer"+                               , "cpdf_page_init"+                               , "cpdf_place_inline_image"+                               , "cpdf_rect"+                               , "cpdf_restore"+                               , "cpdf_rlineto"+                               , "cpdf_rmoveto"+                               , "cpdf_rotate"+                               , "cpdf_rotate_text"+                               , "cpdf_save"+                               , "cpdf_save_to_file"+                               , "cpdf_scale"+                               , "cpdf_set_action_url"+                               , "cpdf_set_char_spacing"+                               , "cpdf_set_creator"+                               , "cpdf_set_current_page"+                               , "cpdf_set_font"+                               , "cpdf_set_font_directories"+                               , "cpdf_set_font_map_file"+                               , "cpdf_set_horiz_scaling"+                               , "cpdf_set_keywords"+                               , "cpdf_set_leading"+                               , "cpdf_set_page_animation"+                               , "cpdf_set_subject"+                               , "cpdf_set_text_matrix"+                               , "cpdf_set_text_pos"+                               , "cpdf_set_text_rendering"+                               , "cpdf_set_text_rise"+                               , "cpdf_set_title"+                               , "cpdf_set_viewer_preferences"+                               , "cpdf_set_word_spacing"+                               , "cpdf_setdash"+                               , "cpdf_setflat"+                               , "cpdf_setgray"+                               , "cpdf_setgray_fill"+                               , "cpdf_setgray_stroke"+                               , "cpdf_setlinecap"+                               , "cpdf_setlinejoin"+                               , "cpdf_setlinewidth"+                               , "cpdf_setmiterlimit"+                               , "cpdf_setrgbcolor"+                               , "cpdf_setrgbcolor_fill"+                               , "cpdf_setrgbcolor_stroke"+                               , "cpdf_show"+                               , "cpdf_show_xy"+                               , "cpdf_stringwidth"+                               , "cpdf_stroke"+                               , "cpdf_text"+                               , "cpdf_translate"+                               , "crack_check"+                               , "crack_closedict"+                               , "crack_getlastmessage"+                               , "crack_opendict"+                               , "crc32"+                               , "create_function"+                               , "crypt"+                               , "ctype_alnum"+                               , "ctype_alpha"+                               , "ctype_cntrl"+                               , "ctype_digit"+                               , "ctype_graph"+                               , "ctype_lower"+                               , "ctype_print"+                               , "ctype_punct"+                               , "ctype_space"+                               , "ctype_upper"+                               , "ctype_xdigit"+                               , "curl_close"+                               , "curl_copy_handle"+                               , "curl_errno"+                               , "curl_error"+                               , "curl_exec"+                               , "curl_getinfo"+                               , "curl_init"+                               , "curl_multi_add_handle"+                               , "curl_multi_close"+                               , "curl_multi_exec"+                               , "curl_multi_getcontent"+                               , "curl_multi_info_read"+                               , "curl_multi_init"+                               , "curl_multi_remove_handle"+                               , "curl_multi_select"+                               , "curl_setopt"+                               , "curl_setopt_array"+                               , "curl_version"+                               , "current"+                               , "cybercash_base64_decode"+                               , "cybercash_base64_encode"+                               , "cybercash_decr"+                               , "cybercash_encr"+                               , "cybermut_creerformulairecm"+                               , "cybermut_creerreponsecm"+                               , "cybermut_testmac"+                               , "cyrus_authenticate"+                               , "cyrus_bind"+                               , "cyrus_close"+                               , "cyrus_connect"+                               , "cyrus_query"+                               , "cyrus_unbind"+                               , "date"+                               , "date_add"+                               , "date_create"+                               , "date_create_from_format"+                               , "date_date_set"+                               , "date_default_timezone_get"+                               , "date_default_timezone_set"+                               , "date_diff"+                               , "date_format"+                               , "date_get_last_errors"+                               , "date_interval_create_from_date_string"+                               , "date_interval_format"+                               , "date_isodate_set"+                               , "date_modify"+                               , "date_offset_get"+                               , "date_parse"+                               , "date_parse_from_format"+                               , "date_sub"+                               , "date_sun_info"+                               , "date_sunrise"+                               , "date_sunset"+                               , "date_time_ set"+                               , "date_timestamp_get"+                               , "date_timestamp_set"+                               , "date_timezone_get"+                               , "date_timezone_set"+                               , "dba_close"+                               , "dba_delete"+                               , "dba_exists"+                               , "dba_fetch"+                               , "dba_firstkey"+                               , "dba_handlers"+                               , "dba_insert"+                               , "dba_key_split"+                               , "dba_list"+                               , "dba_nextkey"+                               , "dba_open"+                               , "dba_optimize"+                               , "dba_popen"+                               , "dba_replace"+                               , "dba_sync"+                               , "dbase_add_record"+                               , "dbase_close"+                               , "dbase_create"+                               , "dbase_delete_record"+                               , "dbase_get_header_info"+                               , "dbase_get_record"+                               , "dbase_get_record_with_names"+                               , "dbase_numfields"+                               , "dbase_numrecords"+                               , "dbase_open"+                               , "dbase_pack"+                               , "dbase_replace_record"+                               , "dblist"+                               , "dbmclose"+                               , "dbmdelete"+                               , "dbmexists"+                               , "dbmfetch"+                               , "dbmfirstkey"+                               , "dbminsert"+                               , "dbmnextkey"+                               , "dbmopen"+                               , "dbmreplace"+                               , "dbplus_add"+                               , "dbplus_aql"+                               , "dbplus_chdir"+                               , "dbplus_close"+                               , "dbplus_curr"+                               , "dbplus_errcode"+                               , "dbplus_errno"+                               , "dbplus_find"+                               , "dbplus_first"+                               , "dbplus_flush"+                               , "dbplus_freealllocks"+                               , "dbplus_freelock"+                               , "dbplus_freerlocks"+                               , "dbplus_getlock"+                               , "dbplus_getunique"+                               , "dbplus_info"+                               , "dbplus_last"+                               , "dbplus_lockrel"+                               , "dbplus_next"+                               , "dbplus_open"+                               , "dbplus_prev"+                               , "dbplus_rchperm"+                               , "dbplus_rcreate"+                               , "dbplus_rcrtexact"+                               , "dbplus_rcrtlike"+                               , "dbplus_resolve"+                               , "dbplus_restorepos"+                               , "dbplus_rkeys"+                               , "dbplus_ropen"+                               , "dbplus_rquery"+                               , "dbplus_rrename"+                               , "dbplus_rsecindex"+                               , "dbplus_runlink"+                               , "dbplus_rzap"+                               , "dbplus_savepos"+                               , "dbplus_setindex"+                               , "dbplus_setindexbynumber"+                               , "dbplus_sql"+                               , "dbplus_tcl"+                               , "dbplus_tremove"+                               , "dbplus_undo"+                               , "dbplus_undoprepare"+                               , "dbplus_unlockrel"+                               , "dbplus_unselect"+                               , "dbplus_update"+                               , "dbplus_xlockrel"+                               , "dbplus_xunlockrel"+                               , "dbx_close"+                               , "dbx_compare"+                               , "dbx_connect"+                               , "dbx_error"+                               , "dbx_escape_string"+                               , "dbx_fetch_row"+                               , "dbx_query"+                               , "dbx_sort"+                               , "dcgettext"+                               , "dcngettext"+                               , "debug_backtrace"+                               , "debug_print_backtrace"+                               , "debug_zval_dump"+                               , "decbin"+                               , "dechex"+                               , "decoct"+                               , "define"+                               , "define_syslog_variables"+                               , "defined"+                               , "deg2rad"+                               , "dgettext"+                               , "die"+                               , "dio_close"+                               , "dio_fcntl"+                               , "dio_open"+                               , "dio_read"+                               , "dio_seek"+                               , "dio_stat"+                               , "dio_tcsetattr"+                               , "dio_truncate"+                               , "dio_write"+                               , "dir"+                               , "dirname"+                               , "disk_free_space"+                               , "disk_total_space"+                               , "diskfreespace"+                               , "dl"+                               , "dngettext"+                               , "dns_check_record"+                               , "dns_get_mx"+                               , "dns_get_record"+                               , "dom_import_simplexml"+                               , "domxml_add_root"+                               , "domxml_attributes"+                               , "domxml_children"+                               , "domxml_dumpmem"+                               , "domxml_get_attribute"+                               , "domxml_new_child"+                               , "domxml_new_xmldoc"+                               , "domxml_node"+                               , "domxml_node_set_content"+                               , "domxml_node_unlink_node"+                               , "domxml_root"+                               , "domxml_set_attribute"+                               , "domxml_version"+                               , "doubleval"+                               , "each"+                               , "easter_date"+                               , "easter_days"+                               , "ebcdic2ascii"+                               , "echo"+                               , "empty"+                               , "end"+                               , "error_get_last"+                               , "error_log"+                               , "error_reporting"+                               , "escapeshellarg"+                               , "escapeshellcmd"+                               , "eval"+                               , "exec"+                               , "exif_imagetype"+                               , "exif_read_data"+                               , "exif_tagname"+                               , "exif_thumbnail"+                               , "exit"+                               , "exp"+                               , "explode"+                               , "expm1"+                               , "extension_loaded"+                               , "extract"+                               , "ezmlm_hash"+                               , "fam_cancel_monitor"+                               , "fam_close"+                               , "fam_monitor_collection"+                               , "fam_monitor_directory"+                               , "fam_monitor_file"+                               , "fam_next_event"+                               , "fam_open"+                               , "fam_pending"+                               , "fam_resume_monitor"+                               , "fam_suspend_monitor"+                               , "fbsql_affected_rows"+                               , "fbsql_autocommit"+                               , "fbsql_change_user"+                               , "fbsql_close"+                               , "fbsql_commit"+                               , "fbsql_connect"+                               , "fbsql_create_blob"+                               , "fbsql_create_clob"+                               , "fbsql_create_db"+                               , "fbsql_data_seek"+                               , "fbsql_database"+                               , "fbsql_database_password"+                               , "fbsql_db_query"+                               , "fbsql_db_status"+                               , "fbsql_drop_db"+                               , "fbsql_errno"+                               , "fbsql_error"+                               , "fbsql_fetch_array"+                               , "fbsql_fetch_assoc"+                               , "fbsql_fetch_field"+                               , "fbsql_fetch_lengths"+                               , "fbsql_fetch_object"+                               , "fbsql_fetch_row"+                               , "fbsql_field_flags"+                               , "fbsql_field_len"+                               , "fbsql_field_name"+                               , "fbsql_field_seek"+                               , "fbsql_field_table"+                               , "fbsql_field_type"+                               , "fbsql_free_result"+                               , "fbsql_get_autostart_info"+                               , "fbsql_hostname"+                               , "fbsql_insert_id"+                               , "fbsql_list_dbs"+                               , "fbsql_list_fields"+                               , "fbsql_list_tables"+                               , "fbsql_next_result"+                               , "fbsql_num_fields"+                               , "fbsql_num_rows"+                               , "fbsql_password"+                               , "fbsql_pconnect"+                               , "fbsql_query"+                               , "fbsql_read_blob"+                               , "fbsql_read_clob"+                               , "fbsql_result"+                               , "fbsql_rollback"+                               , "fbsql_select_db"+                               , "fbsql_set_lob_mode"+                               , "fbsql_set_transaction"+                               , "fbsql_start_db"+                               , "fbsql_stop_db"+                               , "fbsql_tablename"+                               , "fbsql_username"+                               , "fbsql_warnings"+                               , "fclose"+                               , "fdf_add_template"+                               , "fdf_close"+                               , "fdf_create"+                               , "fdf_get_file"+                               , "fdf_get_status"+                               , "fdf_get_value"+                               , "fdf_next_field_name"+                               , "fdf_open"+                               , "fdf_save"+                               , "fdf_set_ap"+                               , "fdf_set_encoding"+                               , "fdf_set_file"+                               , "fdf_set_flags"+                               , "fdf_set_javascript_action"+                               , "fdf_set_opt"+                               , "fdf_set_status"+                               , "fdf_set_submit_form_action"+                               , "fdf_set_value"+                               , "feof"+                               , "fflush"+                               , "fgetc"+                               , "fgetcsv"+                               , "fgets"+                               , "fgetss"+                               , "file"+                               , "file_exists"+                               , "file_get_contents"+                               , "file_put_contents"+                               , "fileatime"+                               , "filectime"+                               , "filegroup"+                               , "fileinode"+                               , "filemtime"+                               , "fileowner"+                               , "fileperms"+                               , "filepro"+                               , "filepro_fieldcount"+                               , "filepro_fieldname"+                               , "filepro_fieldtype"+                               , "filepro_fieldwidth"+                               , "filepro_retrieve"+                               , "filepro_rowcount"+                               , "filesize"+                               , "filetype"+                               , "filter_has_var"+                               , "filter_id"+                               , "filter_input"+                               , "filter_input_array"+                               , "filter_list"+                               , "filter_var"+                               , "filter_var_array"+                               , "floatval"+                               , "flock"+                               , "floor"+                               , "flush"+                               , "fmod"+                               , "fnmatch"+                               , "fopen"+                               , "forward_static_call"+                               , "forward_static_call_array"+                               , "fpassthru"+                               , "fprintf"+                               , "fputcsv"+                               , "fputs"+                               , "fread"+                               , "frenchtojd"+                               , "fribidi_log2vis"+                               , "fscanf"+                               , "fseek"+                               , "fsockopen"+                               , "fstat"+                               , "ftell"+                               , "ftok"+                               , "ftp_alloc"+                               , "ftp_cdup"+                               , "ftp_chdir"+                               , "ftp_chmod"+                               , "ftp_close"+                               , "ftp_connect"+                               , "ftp_delete"+                               , "ftp_exec"+                               , "ftp_fget"+                               , "ftp_fput"+                               , "ftp_get"+                               , "ftp_get_option"+                               , "ftp_login"+                               , "ftp_mdtm"+                               , "ftp_mkdir"+                               , "ftp_nb_continue"+                               , "ftp_nb_fget"+                               , "ftp_nb_fput"+                               , "ftp_nb_get"+                               , "ftp_nb_put"+                               , "ftp_nlist"+                               , "ftp_pasv"+                               , "ftp_put"+                               , "ftp_pwd"+                               , "ftp_quit"+                               , "ftp_raw"+                               , "ftp_rawlist"+                               , "ftp_rename"+                               , "ftp_rmdir"+                               , "ftp_set_option"+                               , "ftp_site"+                               , "ftp_size"+                               , "ftp_ssl_connect"+                               , "ftp_systype"+                               , "ftruncate"+                               , "func_get_arg"+                               , "func_get_args"+                               , "func_num_args"+                               , "function_exists"+                               , "fwrite"+                               , "gc_collect_cycles"+                               , "gc_disable"+                               , "gc_enable"+                               , "gc_enabled"+                               , "gd_info"+                               , "get_browser"+                               , "get_called_class"+                               , "get_cfg_var"+                               , "get_class"+                               , "get_class_methods"+                               , "get_class_vars"+                               , "get_current_user"+                               , "get_declared_classes"+                               , "get_declared_interfaces"+                               , "get_defined_constants"+                               , "get_defined_functions"+                               , "get_defined_vars"+                               , "get_extension_funcs"+                               , "get_headers"+                               , "get_html_translation_table"+                               , "get_include_path"+                               , "get_included_files"+                               , "get_loaded_extensions"+                               , "get_magic_quotes_gpc"+                               , "get_magic_quotes_runtime"+                               , "get_meta_tags"+                               , "get_object_vars"+                               , "get_parent_class"+                               , "get_required_files"+                               , "get_resource_type"+                               , "getallheaders"+                               , "getcwd"+                               , "getdate"+                               , "getenv"+                               , "gethostbyaddr"+                               , "gethostbyname"+                               , "gethostbynamel"+                               , "gethostname"+                               , "getimagesize"+                               , "getlastmod"+                               , "getmxrr"+                               , "getmygid"+                               , "getmyinode"+                               , "getmypid"+                               , "getmyuid"+                               , "getopt"+                               , "getprotobyname"+                               , "getprotobynumber"+                               , "getrandmax"+                               , "getrusage"+                               , "getservbyname"+                               , "getservbyport"+                               , "gettext"+                               , "gettimeofday"+                               , "gettype"+                               , "glob"+                               , "gmdate"+                               , "gmmktime"+                               , "gmp_abs"+                               , "gmp_add"+                               , "gmp_and"+                               , "gmp_clrbit"+                               , "gmp_cmp"+                               , "gmp_com"+                               , "gmp_div"+                               , "gmp_div_q"+                               , "gmp_div_qr"+                               , "gmp_div_r"+                               , "gmp_divexact"+                               , "gmp_fact"+                               , "gmp_gcd"+                               , "gmp_gcdext"+                               , "gmp_hamdist"+                               , "gmp_init"+                               , "gmp_intval"+                               , "gmp_invert"+                               , "gmp_jacobi"+                               , "gmp_legendre"+                               , "gmp_mod"+                               , "gmp_mul"+                               , "gmp_neg"+                               , "gmp_or"+                               , "gmp_perfect_square"+                               , "gmp_popcount"+                               , "gmp_pow"+                               , "gmp_powm"+                               , "gmp_prob_prime"+                               , "gmp_random"+                               , "gmp_scan0"+                               , "gmp_scan1"+                               , "gmp_setbit"+                               , "gmp_sign"+                               , "gmp_sqrt"+                               , "gmp_sqrtrem"+                               , "gmp_strval"+                               , "gmp_sub"+                               , "gmp_xor"+                               , "gmstrftime"+                               , "gregoriantojd"+                               , "gzclose"+                               , "gzcompress"+                               , "gzdeflate"+                               , "gzencode"+                               , "gzeof"+                               , "gzfile"+                               , "gzgetc"+                               , "gzgets"+                               , "gzgetss"+                               , "gzinflate"+                               , "gzopen"+                               , "gzpassthru"+                               , "gzputs"+                               , "gzread"+                               , "gzrewind"+                               , "gzseek"+                               , "gztell"+                               , "gzuncompress"+                               , "gzwrite"+                               , "hash"+                               , "hash_algos"+                               , "hash_copy"+                               , "hash_file"+                               , "hash_final"+                               , "hash_hmac"+                               , "hash_hmac_file"+                               , "hash_init"+                               , "hash_update"+                               , "hash_update_file"+                               , "hash_update_stream"+                               , "header"+                               , "header_remove"+                               , "headers_list"+                               , "headers_sent"+                               , "hebrev"+                               , "hebrevc"+                               , "hexdec"+                               , "highlight_file"+                               , "highlight_string"+                               , "html_entity_decode"+                               , "htmlentities"+                               , "htmlspecialchars"+                               , "htmlspecialchars_decode"+                               , "http_build_query"+                               , "hw_array2objrec"+                               , "hw_changeobject"+                               , "hw_children"+                               , "hw_childrenobj"+                               , "hw_close"+                               , "hw_connect"+                               , "hw_connection_info"+                               , "hw_cp"+                               , "hw_deleteobject"+                               , "hw_docbyanchor"+                               , "hw_docbyanchorobj"+                               , "hw_document_attributes"+                               , "hw_document_bodytag"+                               , "hw_document_content"+                               , "hw_document_setcontent"+                               , "hw_document_size"+                               , "hw_dummy"+                               , "hw_edittext"+                               , "hw_error"+                               , "hw_errormsg"+                               , "hw_free_document"+                               , "hw_getanchors"+                               , "hw_getanchorsobj"+                               , "hw_getandlock"+                               , "hw_getchildcoll"+                               , "hw_getchildcollobj"+                               , "hw_getchilddoccoll"+                               , "hw_getchilddoccollobj"+                               , "hw_getobject"+                               , "hw_getobjectbyquery"+                               , "hw_getobjectbyquerycoll"+                               , "hw_getobjectbyquerycollobj"+                               , "hw_getobjectbyqueryobj"+                               , "hw_getparents"+                               , "hw_getparentsobj"+                               , "hw_getrellink"+                               , "hw_getremote"+                               , "hw_getremotechildren"+                               , "hw_getsrcbydestobj"+                               , "hw_gettext"+                               , "hw_getusername"+                               , "hw_identify"+                               , "hw_incollections"+                               , "hw_info"+                               , "hw_inscoll"+                               , "hw_insdoc"+                               , "hw_insertanchors"+                               , "hw_insertdocument"+                               , "hw_insertobject"+                               , "hw_mapid"+                               , "hw_modifyobject"+                               , "hw_mv"+                               , "hw_new_document"+                               , "hw_objrec2array"+                               , "hw_output_document"+                               , "hw_pconnect"+                               , "hw_pipedocument"+                               , "hw_root"+                               , "hw_setlinkroot"+                               , "hw_stat"+                               , "hw_unlock"+                               , "hw_who"+                               , "hypot"+                               , "ibase_blob_add"+                               , "ibase_blob_cancel"+                               , "ibase_blob_close"+                               , "ibase_blob_create"+                               , "ibase_blob_echo"+                               , "ibase_blob_get"+                               , "ibase_blob_import"+                               , "ibase_blob_info"+                               , "ibase_blob_open"+                               , "ibase_close"+                               , "ibase_commit"+                               , "ibase_connect"+                               , "ibase_errmsg"+                               , "ibase_execute"+                               , "ibase_fetch_object"+                               , "ibase_fetch_row"+                               , "ibase_field_info"+                               , "ibase_free_query"+                               , "ibase_free_result"+                               , "ibase_num_fields"+                               , "ibase_pconnect"+                               , "ibase_prepare"+                               , "ibase_query"+                               , "ibase_rollback"+                               , "ibase_timefmt"+                               , "ibase_trans"+                               , "icap_close"+                               , "icap_create_calendar"+                               , "icap_delete_calendar"+                               , "icap_delete_event"+                               , "icap_fetch_event"+                               , "icap_list_alarms"+                               , "icap_list_events"+                               , "icap_open"+                               , "icap_rename_calendar"+                               , "icap_reopen"+                               , "icap_snooze"+                               , "icap_store_event"+                               , "iconv"+                               , "iconv_get_encoding"+                               , "iconv_mime_decode"+                               , "iconv_mime_decode_headers"+                               , "iconv_mime_encode"+                               , "iconv_set_encoding"+                               , "iconv_strlen"+                               , "iconv_strpos"+                               , "iconv_strrpos"+                               , "iconv_substr"+                               , "idate"+                               , "ifx_affected_rows"+                               , "ifx_blobinfile_mode"+                               , "ifx_byteasvarchar"+                               , "ifx_close"+                               , "ifx_connect"+                               , "ifx_copy_blob"+                               , "ifx_create_blob"+                               , "ifx_create_char"+                               , "ifx_do"+                               , "ifx_error"+                               , "ifx_errormsg"+                               , "ifx_fetch_row"+                               , "ifx_fieldproperties"+                               , "ifx_fieldtypes"+                               , "ifx_free_blob"+                               , "ifx_free_char"+                               , "ifx_free_result"+                               , "ifx_get_blob"+                               , "ifx_get_char"+                               , "ifx_getsqlca"+                               , "ifx_htmltbl_result"+                               , "ifx_nullformat"+                               , "ifx_num_fields"+                               , "ifx_num_rows"+                               , "ifx_pconnect"+                               , "ifx_prepare"+                               , "ifx_query"+                               , "ifx_textasvarchar"+                               , "ifx_update_blob"+                               , "ifx_update_char"+                               , "ifxus_close_slob"+                               , "ifxus_create_slob"+                               , "ifxus_free_slob"+                               , "ifxus_open_slob"+                               , "ifxus_read_slob"+                               , "ifxus_seek_slob"+                               , "ifxus_tell_slob"+                               , "ifxus_write_slob"+                               , "ignore_user_abort"+                               , "image2wbmp"+                               , "image_type_to_extension"+                               , "image_type_to_mime_type"+                               , "imagealphablending"+                               , "imageantialias"+                               , "imagearc"+                               , "imagechar"+                               , "imagecharup"+                               , "imagecolorallocate"+                               , "imagecolorallocatealpha"+                               , "imagecolorat"+                               , "imagecolorclosest"+                               , "imagecolorclosestalpha"+                               , "imagecolorclosesthwb"+                               , "imagecolordeallocate"+                               , "imagecolorexact"+                               , "imagecolorexactalpha"+                               , "imagecolormatch"+                               , "imagecolorresolve"+                               , "imagecolorresolvealpha"+                               , "imagecolorset"+                               , "imagecolorsforindex"+                               , "imagecolorstotal"+                               , "imagecolortransparent"+                               , "imageconvolution"+                               , "imagecopy"+                               , "imagecopymerge"+                               , "imagecopymergegray"+                               , "imagecopyresampled"+                               , "imagecopyresized"+                               , "imagecreate"+                               , "imagecreatefromgd"+                               , "imagecreatefromgd2"+                               , "imagecreatefromgd2part"+                               , "imagecreatefromgif"+                               , "imagecreatefromjpeg"+                               , "imagecreatefrompng"+                               , "imagecreatefromstring"+                               , "imagecreatefromwbmp"+                               , "imagecreatefromxbm"+                               , "imagecreatefromxpm"+                               , "imagecreatetruecolor"+                               , "imagedashedline"+                               , "imagedestroy"+                               , "imageellipse"+                               , "imagefill"+                               , "imagefilledarc"+                               , "imagefilledellipse"+                               , "imagefilledpolygon"+                               , "imagefilledrectangle"+                               , "imagefilltoborder"+                               , "imagefilter"+                               , "imagefontheight"+                               , "imagefontwidth"+                               , "imageftbbox"+                               , "imagefttext"+                               , "imagegammacorrect"+                               , "imagegd"+                               , "imagegd2"+                               , "imagegif"+                               , "imageinterlace"+                               , "imageistruecolor"+                               , "imagejpeg"+                               , "imagelayereffect"+                               , "imageline"+                               , "imageloadfont"+                               , "imagepalettecopy"+                               , "imagepng"+                               , "imagepolygon"+                               , "imagepsbbox"+                               , "imagepsencodefont"+                               , "imagepsextendfont"+                               , "imagepsfreefont"+                               , "imagepsloadfont"+                               , "imagepsslantfont"+                               , "imagepstext"+                               , "imagerectangle"+                               , "imagerotate"+                               , "imagesavealpha"+                               , "imagesetbrush"+                               , "imagesetpixel"+                               , "imagesetstyle"+                               , "imagesetthickness"+                               , "imagesettile"+                               , "imagestring"+                               , "imagestringup"+                               , "imagesx"+                               , "imagesy"+                               , "imagetruecolortopalette"+                               , "imagettfbbox"+                               , "imagettftext"+                               , "imagetypes"+                               , "imagewbmp"+                               , "imagexbm"+                               , "imap_8bit"+                               , "imap_alerts"+                               , "imap_append"+                               , "imap_base64"+                               , "imap_binary"+                               , "imap_body"+                               , "imap_bodystruct"+                               , "imap_check"+                               , "imap_clearflag_full"+                               , "imap_close"+                               , "imap_create"+                               , "imap_createmailbox"+                               , "imap_delete"+                               , "imap_deletemailbox"+                               , "imap_errors"+                               , "imap_expunge"+                               , "imap_fetch_overview"+                               , "imap_fetchbody"+                               , "imap_fetchheader"+                               , "imap_fetchstructure"+                               , "imap_fetchtext"+                               , "imap_get_quota"+                               , "imap_get_quotaroot"+                               , "imap_getacl"+                               , "imap_getmailboxes"+                               , "imap_getsubscribed"+                               , "imap_header"+                               , "imap_headerinfo"+                               , "imap_headers"+                               , "imap_last_error"+                               , "imap_list"+                               , "imap_listmailbox"+                               , "imap_listsubscribed"+                               , "imap_lsub"+                               , "imap_mail"+                               , "imap_mail_compose"+                               , "imap_mail_copy"+                               , "imap_mail_move"+                               , "imap_mailboxmsginfo"+                               , "imap_mime_header_decode"+                               , "imap_msgno"+                               , "imap_num_msg"+                               , "imap_num_recent"+                               , "imap_open"+                               , "imap_ping"+                               , "imap_popen"+                               , "imap_qprint"+                               , "imap_rename"+                               , "imap_renamemailbox"+                               , "imap_reopen"+                               , "imap_rfc822_parse_adrlist"+                               , "imap_rfc822_parse_headers"+                               , "imap_rfc822_write_address"+                               , "imap_scan"+                               , "imap_scanmailbox"+                               , "imap_search"+                               , "imap_set_quota"+                               , "imap_setacl"+                               , "imap_setflag_full"+                               , "imap_sort"+                               , "imap_status"+                               , "imap_subscribe"+                               , "imap_thread"+                               , "imap_timeout"+                               , "imap_uid"+                               , "imap_undelete"+                               , "imap_unsubscribe"+                               , "imap_utf7_decode"+                               , "imap_utf7_encode"+                               , "imap_utf8"+                               , "implode"+                               , "import_request_variables"+                               , "in_array"+                               , "include"+                               , "include_once"+                               , "inet_ntop"+                               , "inet_pton"+                               , "ingres_autocommit"+                               , "ingres_close"+                               , "ingres_commit"+                               , "ingres_connect"+                               , "ingres_fetch_array"+                               , "ingres_fetch_object"+                               , "ingres_fetch_row"+                               , "ingres_field_length"+                               , "ingres_field_name"+                               , "ingres_field_nullable"+                               , "ingres_field_precision"+                               , "ingres_field_scale"+                               , "ingres_field_type"+                               , "ingres_num_fields"+                               , "ingres_num_rows"+                               , "ingres_pconnect"+                               , "ingres_query"+                               , "ingres_rollback"+                               , "ini_alter"+                               , "ini_get"+                               , "ini_get_all"+                               , "ini_restore"+                               , "ini_set"+                               , "interface_exists"+                               , "intval"+                               , "ip2long"+                               , "iptcembed"+                               , "iptcparse"+                               , "ircg_channel_mode"+                               , "ircg_disconnect"+                               , "ircg_fetch_error_msg"+                               , "ircg_get_username"+                               , "ircg_html_encode"+                               , "ircg_ignore_add"+                               , "ircg_ignore_del"+                               , "ircg_is_conn_alive"+                               , "ircg_join"+                               , "ircg_kick"+                               , "ircg_lookup_format_messages"+                               , "ircg_msg"+                               , "ircg_nick"+                               , "ircg_nickname_escape"+                               , "ircg_nickname_unescape"+                               , "ircg_notice"+                               , "ircg_part"+                               , "ircg_pconnect"+                               , "ircg_register_format_messages"+                               , "ircg_set_current"+                               , "ircg_set_file"+                               , "ircg_set_on_die"+                               , "ircg_topic"+                               , "ircg_whois"+                               , "is_a"+                               , "is_array"+                               , "is_bool"+                               , "is_callable"+                               , "is_dir"+                               , "is_double"+                               , "is_executable"+                               , "is_file"+                               , "is_finite"+                               , "is_float"+                               , "is_infinite"+                               , "is_int"+                               , "is_integer"+                               , "is_link"+                               , "is_long"+                               , "is_nan"+                               , "is_null"+                               , "is_numeric"+                               , "is_object"+                               , "is_readable"+                               , "is_real"+                               , "is_resource"+                               , "is_scalar"+                               , "is_string"+                               , "is_subclass_of"+                               , "is_uploaded_file"+                               , "is_writable"+                               , "is_writeable"+                               , "isset"+                               , "iterator_apply"+                               , "iterator_count"+                               , "iterator_to_array"+                               , "java_last_exception_clear"+                               , "java_last_exception_get"+                               , "jddayofweek"+                               , "jdmonthname"+                               , "jdtofrench"+                               , "jdtogregorian"+                               , "jdtojewish"+                               , "jdtojulian"+                               , "jdtounix"+                               , "jewishtojd"+                               , "join"+                               , "jpeg2wbmp"+                               , "json_decode"+                               , "json_encode"+                               , "json_last_error"+                               , "juliantojd"+                               , "key"+                               , "key_exists"+                               , "krsort"+                               , "ksort"+                               , "lcfirst"+                               , "lcg_value"+                               , "lchgrp"+                               , "lchown"+                               , "ldap_8859_to_t61"+                               , "ldap_add"+                               , "ldap_bind"+                               , "ldap_close"+                               , "ldap_compare"+                               , "ldap_connect"+                               , "ldap_count_entries"+                               , "ldap_delete"+                               , "ldap_dn2ufn"+                               , "ldap_err2str"+                               , "ldap_errno"+                               , "ldap_error"+                               , "ldap_explode_dn"+                               , "ldap_first_attribute"+                               , "ldap_first_entry"+                               , "ldap_first_reference"+                               , "ldap_free_result"+                               , "ldap_get_attributes"+                               , "ldap_get_dn"+                               , "ldap_get_entries"+                               , "ldap_get_option"+                               , "ldap_get_values"+                               , "ldap_get_values_len"+                               , "ldap_list"+                               , "ldap_mod_add"+                               , "ldap_mod_del"+                               , "ldap_mod_replace"+                               , "ldap_modify"+                               , "ldap_next_attribute"+                               , "ldap_next_entry"+                               , "ldap_next_reference"+                               , "ldap_parse_reference"+                               , "ldap_parse_result"+                               , "ldap_read"+                               , "ldap_rename"+                               , "ldap_search"+                               , "ldap_set_option"+                               , "ldap_set_rebind_proc"+                               , "ldap_sort"+                               , "ldap_start_tls"+                               , "ldap_t61_to_8859"+                               , "ldap_unbind"+                               , "levenshtein"+                               , "libxml_clear_errors"+                               , "libxml_get_errors"+                               , "libxml_get_last_error"+                               , "libxml_set_streams_context"+                               , "libxml_use_internal_errors"+                               , "link"+                               , "linkinfo"+                               , "list"+                               , "localeconv"+                               , "localtime"+                               , "log"+                               , "log10"+                               , "log1p"+                               , "long2ip"+                               , "lstat"+                               , "ltrim"+                               , "magic_quotes_runtime"+                               , "mail"+                               , "mailparse_determine_best_xfer_encoding"+                               , "mailparse_msg_create"+                               , "mailparse_msg_extract_part"+                               , "mailparse_msg_extract_part_file"+                               , "mailparse_msg_free"+                               , "mailparse_msg_get_part"+                               , "mailparse_msg_get_part_data"+                               , "mailparse_msg_get_structure"+                               , "mailparse_msg_parse"+                               , "mailparse_msg_parse_file"+                               , "mailparse_rfc822_parse_addresses"+                               , "mailparse_stream_encode"+                               , "mailparse_uudecode_all"+                               , "max"+                               , "mb_check_encoding"+                               , "mb_convert_case"+                               , "mb_convert_encoding"+                               , "mb_convert_kana"+                               , "mb_convert_variables"+                               , "mb_decode_mimeheader"+                               , "mb_decode_numericentity"+                               , "mb_detect_encoding"+                               , "mb_detect_order"+                               , "mb_encode_mimeheader"+                               , "mb_encode_numericentity"+                               , "mb_encoding_aliases"+                               , "mb_ereg"+                               , "mb_ereg_match"+                               , "mb_ereg_replace"+                               , "mb_ereg_search"+                               , "mb_ereg_search_getpos"+                               , "mb_ereg_search_getregs"+                               , "mb_ereg_search_init"+                               , "mb_ereg_search_pos"+                               , "mb_ereg_search_regs"+                               , "mb_ereg_search_setpos"+                               , "mb_eregi"+                               , "mb_eregi_replace"+                               , "mb_get_info"+                               , "mb_http_input"+                               , "mb_http_output"+                               , "mb_internal_encoding"+                               , "mb_language"+                               , "mb_list_encodings"+                               , "mb_output_handler"+                               , "mb_parse_str"+                               , "mb_preferred_mime_name"+                               , "mb_regex_encoding"+                               , "mb_regex_set_options"+                               , "mb_send_mail"+                               , "mb_split"+                               , "mb_strcut"+                               , "mb_strimwidth"+                               , "mb_stripos"+                               , "mb_stristr"+                               , "mb_strlen"+                               , "mb_strpos"+                               , "mb_strrchr"+                               , "mb_strrichr"+                               , "mb_strripos"+                               , "mb_strrpos"+                               , "mb_strstr"+                               , "mb_strtolower"+                               , "mb_strtoupper"+                               , "mb_strwidth"+                               , "mb_substitute_character"+                               , "mb_substr"+                               , "mb_substr_count"+                               , "mcal_append_event"+                               , "mcal_close"+                               , "mcal_create_calendar"+                               , "mcal_date_compare"+                               , "mcal_date_valid"+                               , "mcal_day_of_week"+                               , "mcal_day_of_year"+                               , "mcal_days_in_month"+                               , "mcal_delete_calendar"+                               , "mcal_delete_event"+                               , "mcal_event_add_attribute"+                               , "mcal_event_init"+                               , "mcal_event_set_alarm"+                               , "mcal_event_set_category"+                               , "mcal_event_set_class"+                               , "mcal_event_set_description"+                               , "mcal_event_set_end"+                               , "mcal_event_set_recur_daily"+                               , "mcal_event_set_recur_monthly_mday"+                               , "mcal_event_set_recur_monthly_wday"+                               , "mcal_event_set_recur_none"+                               , "mcal_event_set_recur_weekly"+                               , "mcal_event_set_recur_yearly"+                               , "mcal_event_set_start"+                               , "mcal_event_set_title"+                               , "mcal_expunge"+                               , "mcal_fetch_current_stream_event"+                               , "mcal_fetch_event"+                               , "mcal_is_leap_year"+                               , "mcal_list_alarms"+                               , "mcal_list_events"+                               , "mcal_next_recurrence"+                               , "mcal_open"+                               , "mcal_popen"+                               , "mcal_rename_calendar"+                               , "mcal_reopen"+                               , "mcal_snooze"+                               , "mcal_store_event"+                               , "mcal_time_valid"+                               , "mcal_week_of_year"+                               , "mcrypt_cbc"+                               , "mcrypt_cfb"+                               , "mcrypt_create_iv"+                               , "mcrypt_decrypt"+                               , "mcrypt_enc_get_algorithms_name"+                               , "mcrypt_enc_get_block_size"+                               , "mcrypt_enc_get_iv_size"+                               , "mcrypt_enc_get_key_size"+                               , "mcrypt_enc_get_modes_name"+                               , "mcrypt_enc_get_supported_key_sizes"+                               , "mcrypt_enc_is_block_algorithm"+                               , "mcrypt_enc_is_block_algorithm_mode"+                               , "mcrypt_enc_is_block_mode"+                               , "mcrypt_enc_self_test"+                               , "mcrypt_encrypt"+                               , "mcrypt_generic"+                               , "mcrypt_generic_deinit"+                               , "mcrypt_generic_end"+                               , "mcrypt_generic_init"+                               , "mcrypt_get_block_size"+                               , "mcrypt_get_cipher_name"+                               , "mcrypt_get_iv_size"+                               , "mcrypt_get_key_size"+                               , "mcrypt_list_algorithms"+                               , "mcrypt_list_modes"+                               , "mcrypt_module_close"+                               , "mcrypt_module_get_algo_block_size"+                               , "mcrypt_module_get_algo_key_size"+                               , "mcrypt_module_get_supported_key_sizes"+                               , "mcrypt_module_is_block_algorithm"+                               , "mcrypt_module_is_block_algorithm_mode"+                               , "mcrypt_module_is_block_mode"+                               , "mcrypt_module_open"+                               , "mcrypt_module_self_test"+                               , "mcrypt_ofb"+                               , "md5"+                               , "md5_file"+                               , "mdecrypt_generic"+                               , "memory_get_peak_usage"+                               , "memory_get_usage"+                               , "metaphone"+                               , "method_exists"+                               , "mhash"+                               , "mhash_count"+                               , "mhash_get_block_size"+                               , "mhash_get_hash_name"+                               , "mhash_keygen_s2k"+                               , "microtime"+                               , "min"+                               , "ming_setcubicthreshold"+                               , "ming_setscale"+                               , "ming_useswfversion"+                               , "mkdir"+                               , "mktime"+                               , "money_format"+                               , "move_uploaded_file"+                               , "msession_connect"+                               , "msession_count"+                               , "msession_create"+                               , "msession_destroy"+                               , "msession_disconnect"+                               , "msession_find"+                               , "msession_get"+                               , "msession_get_array"+                               , "msession_getdata"+                               , "msession_inc"+                               , "msession_list"+                               , "msession_listvar"+                               , "msession_lock"+                               , "msession_plugin"+                               , "msession_randstr"+                               , "msession_set"+                               , "msession_set_array"+                               , "msession_setdata"+                               , "msession_timeout"+                               , "msession_uniq"+                               , "msession_unlock"+                               , "msg_get_queue"+                               , "msg_receive"+                               , "msg_remove_queue"+                               , "msg_send"+                               , "msg_set_queue"+                               , "msg_stat_queue"+                               , "msql"+                               , "msql_affected_rows"+                               , "msql_close"+                               , "msql_connect"+                               , "msql_create_db"+                               , "msql_createdb"+                               , "msql_data_seek"+                               , "msql_dbname"+                               , "msql_drop_db"+                               , "msql_dropdb"+                               , "msql_error"+                               , "msql_fetch_array"+                               , "msql_fetch_field"+                               , "msql_fetch_object"+                               , "msql_fetch_row"+                               , "msql_field_seek"+                               , "msql_fieldflags"+                               , "msql_fieldlen"+                               , "msql_fieldname"+                               , "msql_fieldtable"+                               , "msql_fieldtype"+                               , "msql_free_result"+                               , "msql_freeresult"+                               , "msql_list_dbs"+                               , "msql_list_fields"+                               , "msql_list_tables"+                               , "msql_listdbs"+                               , "msql_listfields"+                               , "msql_listtables"+                               , "msql_num_fields"+                               , "msql_num_rows"+                               , "msql_numfields"+                               , "msql_numrows"+                               , "msql_pconnect"+                               , "msql_query"+                               , "msql_regcase"+                               , "msql_result"+                               , "msql_select_db"+                               , "msql_selectdb"+                               , "msql_tablename"+                               , "mssql_bind"+                               , "mssql_close"+                               , "mssql_connect"+                               , "mssql_data_seek"+                               , "mssql_execute"+                               , "mssql_fetch_array"+                               , "mssql_fetch_assoc"+                               , "mssql_fetch_batch"+                               , "mssql_fetch_field"+                               , "mssql_fetch_object"+                               , "mssql_fetch_row"+                               , "mssql_field_length"+                               , "mssql_field_name"+                               , "mssql_field_seek"+                               , "mssql_field_type"+                               , "mssql_free_result"+                               , "mssql_get_last_message"+                               , "mssql_guid_string"+                               , "mssql_init"+                               , "mssql_min_error_severity"+                               , "mssql_min_message_severity"+                               , "mssql_next_result"+                               , "mssql_num_fields"+                               , "mssql_num_rows"+                               , "mssql_pconnect"+                               , "mssql_query"+                               , "mssql_result"+                               , "mssql_rows_affected"+                               , "mssql_select_db"+                               , "mt_getrandmax"+                               , "mt_rand"+                               , "mt_srand"+                               , "muscat_close"+                               , "muscat_get"+                               , "muscat_give"+                               , "muscat_setup"+                               , "muscat_setup_net"+                               , "mysql"+                               , "mysql_affected_rows"+                               , "mysql_client_encoding"+                               , "mysql_close"+                               , "mysql_connect"+                               , "mysql_data_seek"+                               , "mysql_db_name"+                               , "mysql_db_query"+                               , "mysql_errno"+                               , "mysql_error"+                               , "mysql_escape_string"+                               , "mysql_fetch_array"+                               , "mysql_fetch_assoc"+                               , "mysql_fetch_field"+                               , "mysql_fetch_lengths"+                               , "mysql_fetch_object"+                               , "mysql_fetch_row"+                               , "mysql_field_flags"+                               , "mysql_field_len"+                               , "mysql_field_name"+                               , "mysql_field_seek"+                               , "mysql_field_table"+                               , "mysql_field_type"+                               , "mysql_free_result"+                               , "mysql_get_client_info"+                               , "mysql_get_host_info"+                               , "mysql_get_proto_info"+                               , "mysql_get_server_info"+                               , "mysql_info"+                               , "mysql_insert_id"+                               , "mysql_list_dbs"+                               , "mysql_list_processes"+                               , "mysql_num_fields"+                               , "mysql_num_rows"+                               , "mysql_pconnect"+                               , "mysql_ping"+                               , "mysql_query"+                               , "mysql_real_escape_string"+                               , "mysql_result"+                               , "mysql_select_db"+                               , "mysql_set_charset"+                               , "mysql_stat"+                               , "mysql_table_name"+                               , "mysql_thread_id"+                               , "mysql_unbuffered_query"+                               , "mysqli_affected_rows"+                               , "mysqli_autocommit"+                               , "mysqli_bind_param"+                               , "mysqli_bind_result"+                               , "mysqli_change_user"+                               , "mysqli_character_set_name"+                               , "mysqli_client_encoding"+                               , "mysqli_close"+                               , "mysqli_commit"+                               , "mysqli_connect"+                               , "mysqli_connect_errno"+                               , "mysqli_connect_error"+                               , "mysqli_data_seek"+                               , "mysqli_debug"+                               , "mysqli_dump_debug_info"+                               , "mysqli_errno"+                               , "mysqli_error"+                               , "mysqli_escape_string"+                               , "mysqli_execute"+                               , "mysqli_fetch"+                               , "mysqli_fetch_array"+                               , "mysqli_fetch_assoc"+                               , "mysqli_fetch_field"+                               , "mysqli_fetch_field_direct"+                               , "mysqli_fetch_fields"+                               , "mysqli_fetch_lengths"+                               , "mysqli_fetch_object"+                               , "mysqli_fetch_row"+                               , "mysqli_field_count"+                               , "mysqli_field_seek"+                               , "mysqli_field_tell"+                               , "mysqli_free_result"+                               , "mysqli_get_cache_stats"+                               , "mysqli_get_client_info"+                               , "mysqli_get_client_stats"+                               , "mysqli_get_client_version"+                               , "mysqli_get_host_info"+                               , "mysqli_get_metadata"+                               , "mysqli_get_proto_info"+                               , "mysqli_get_server_info"+                               , "mysqli_get_server_version"+                               , "mysqli_info"+                               , "mysqli_init"+                               , "mysqli_insert_id"+                               , "mysqli_kill"+                               , "mysqli_more_results"+                               , "mysqli_multi_query"+                               , "mysqli_next_result"+                               , "mysqli_num_fields"+                               , "mysqli_num_rows"+                               , "mysqli_options"+                               , "mysqli_param_count"+                               , "mysqli_ping"+                               , "mysqli_prepare"+                               , "mysqli_query"+                               , "mysqli_real_connect"+                               , "mysqli_real_escape_string"+                               , "mysqli_real_query"+                               , "mysqli_refresh"+                               , "mysqli_report"+                               , "mysqli_rollback"+                               , "mysqli_select_db"+                               , "mysqli_send_long_data"+                               , "mysqli_set_charset"+                               , "mysqli_set_local_infile_default"+                               , "mysqli_set_local_infile_handler"+                               , "mysqli_set_opt"+                               , "mysqli_sqlstate"+                               , "mysqli_ssl_set"+                               , "mysqli_stat"+                               , "mysqli_stmt_affected_rows"+                               , "mysqli_stmt_attr_get"+                               , "mysqli_stmt_attr_set"+                               , "mysqli_stmt_bind_param"+                               , "mysqli_stmt_bind_result"+                               , "mysqli_stmt_close"+                               , "mysqli_stmt_data_seek"+                               , "mysqli_stmt_errno"+                               , "mysqli_stmt_error"+                               , "mysqli_stmt_execute"+                               , "mysqli_stmt_fetch"+                               , "mysqli_stmt_field_count"+                               , "mysqli_stmt_free_result"+                               , "mysqli_stmt_get_warnings"+                               , "mysqli_stmt_init"+                               , "mysqli_stmt_insert_id"+                               , "mysqli_stmt_num_rows"+                               , "mysqli_stmt_param_count"+                               , "mysqli_stmt_prepare"+                               , "mysqli_stmt_reset"+                               , "mysqli_stmt_result_metadata"+                               , "mysqli_stmt_send_long_data"+                               , "mysqli_stmt_sqlstate"+                               , "mysqli_stmt_store_result"+                               , "mysqli_store_result"+                               , "mysqli_thread_id"+                               , "mysqli_thread_safe"+                               , "mysqli_use_result"+                               , "mysqli_warning_count"+                               , "natcasesort"+                               , "natsort"+                               , "ncurses_addch"+                               , "ncurses_addchnstr"+                               , "ncurses_addchstr"+                               , "ncurses_addnstr"+                               , "ncurses_addstr"+                               , "ncurses_assume_default_colors"+                               , "ncurses_attroff"+                               , "ncurses_attron"+                               , "ncurses_attrset"+                               , "ncurses_baudrate"+                               , "ncurses_beep"+                               , "ncurses_bkgd"+                               , "ncurses_bkgdset"+                               , "ncurses_border"+                               , "ncurses_bottom_panel"+                               , "ncurses_can_change_color"+                               , "ncurses_cbreak"+                               , "ncurses_clear"+                               , "ncurses_clrtobot"+                               , "ncurses_clrtoeol"+                               , "ncurses_color_content"+                               , "ncurses_color_set"+                               , "ncurses_curs_set"+                               , "ncurses_def_prog_mode"+                               , "ncurses_def_shell_mode"+                               , "ncurses_define_key"+                               , "ncurses_del_panel"+                               , "ncurses_delay_output"+                               , "ncurses_delch"+                               , "ncurses_deleteln"+                               , "ncurses_delwin"+                               , "ncurses_doupdate"+                               , "ncurses_echo"+                               , "ncurses_echochar"+                               , "ncurses_end"+                               , "ncurses_erase"+                               , "ncurses_erasechar"+                               , "ncurses_filter"+                               , "ncurses_flash"+                               , "ncurses_flushinp"+                               , "ncurses_getch"+                               , "ncurses_getmaxyx"+                               , "ncurses_getmouse"+                               , "ncurses_getyx"+                               , "ncurses_halfdelay"+                               , "ncurses_has_colors"+                               , "ncurses_has_ic"+                               , "ncurses_has_il"+                               , "ncurses_has_key"+                               , "ncurses_hide_panel"+                               , "ncurses_hline"+                               , "ncurses_inch"+                               , "ncurses_init"+                               , "ncurses_init_color"+                               , "ncurses_init_pair"+                               , "ncurses_insch"+                               , "ncurses_insdelln"+                               , "ncurses_insertln"+                               , "ncurses_insstr"+                               , "ncurses_instr"+                               , "ncurses_isendwin"+                               , "ncurses_keyok"+                               , "ncurses_keypad"+                               , "ncurses_killchar"+                               , "ncurses_longname"+                               , "ncurses_meta"+                               , "ncurses_mouse_trafo"+                               , "ncurses_mouseinterval"+                               , "ncurses_mousemask"+                               , "ncurses_move"+                               , "ncurses_move_panel"+                               , "ncurses_mvaddch"+                               , "ncurses_mvaddchnstr"+                               , "ncurses_mvaddchstr"+                               , "ncurses_mvaddnstr"+                               , "ncurses_mvaddstr"+                               , "ncurses_mvcur"+                               , "ncurses_mvdelch"+                               , "ncurses_mvgetch"+                               , "ncurses_mvhline"+                               , "ncurses_mvinch"+                               , "ncurses_mvvline"+                               , "ncurses_mvwaddstr"+                               , "ncurses_napms"+                               , "ncurses_new_panel"+                               , "ncurses_newpad"+                               , "ncurses_newwin"+                               , "ncurses_nl"+                               , "ncurses_nocbreak"+                               , "ncurses_noecho"+                               , "ncurses_nonl"+                               , "ncurses_noqiflush"+                               , "ncurses_noraw"+                               , "ncurses_pair_content"+                               , "ncurses_panel_above"+                               , "ncurses_panel_below"+                               , "ncurses_panel_window"+                               , "ncurses_pnoutrefresh"+                               , "ncurses_prefresh"+                               , "ncurses_putp"+                               , "ncurses_qiflush"+                               , "ncurses_raw"+                               , "ncurses_refresh"+                               , "ncurses_replace_panel"+                               , "ncurses_reset_prog_mode"+                               , "ncurses_reset_shell_mode"+                               , "ncurses_resetty"+                               , "ncurses_savetty"+                               , "ncurses_scr_dump"+                               , "ncurses_scr_init"+                               , "ncurses_scr_restore"+                               , "ncurses_scr_set"+                               , "ncurses_scrl"+                               , "ncurses_show_panel"+                               , "ncurses_slk_attr"+                               , "ncurses_slk_attroff"+                               , "ncurses_slk_attron"+                               , "ncurses_slk_attrset"+                               , "ncurses_slk_clear"+                               , "ncurses_slk_color"+                               , "ncurses_slk_init"+                               , "ncurses_slk_noutrefresh"+                               , "ncurses_slk_refresh"+                               , "ncurses_slk_restore"+                               , "ncurses_slk_set"+                               , "ncurses_slk_touch"+                               , "ncurses_standend"+                               , "ncurses_standout"+                               , "ncurses_start_color"+                               , "ncurses_termattrs"+                               , "ncurses_termname"+                               , "ncurses_timeout"+                               , "ncurses_top_panel"+                               , "ncurses_typeahead"+                               , "ncurses_ungetch"+                               , "ncurses_ungetmouse"+                               , "ncurses_update_panels"+                               , "ncurses_use_default_colors"+                               , "ncurses_use_env"+                               , "ncurses_use_extended_names"+                               , "ncurses_vidattr"+                               , "ncurses_vline"+                               , "ncurses_waddch"+                               , "ncurses_waddstr"+                               , "ncurses_wattroff"+                               , "ncurses_wattron"+                               , "ncurses_wattrset"+                               , "ncurses_wborder"+                               , "ncurses_wclear"+                               , "ncurses_wcolor_set"+                               , "ncurses_werase"+                               , "ncurses_wgetch"+                               , "ncurses_whline"+                               , "ncurses_wmouse_trafo"+                               , "ncurses_wmove"+                               , "ncurses_wnoutrefresh"+                               , "ncurses_wrefresh"+                               , "ncurses_wstandend"+                               , "ncurses_wstandout"+                               , "ncurses_wvline"+                               , "next"+                               , "ngettext"+                               , "nl2br"+                               , "nl_langinfo"+                               , "notes_body"+                               , "notes_copy_db"+                               , "notes_create_db"+                               , "notes_create_note"+                               , "notes_drop_db"+                               , "notes_find_note"+                               , "notes_header_info"+                               , "notes_list_msgs"+                               , "notes_mark_read"+                               , "notes_mark_unread"+                               , "notes_nav_create"+                               , "notes_search"+                               , "notes_unread"+                               , "notes_version"+                               , "number_format"+                               , "ob_clean"+                               , "ob_end_clean"+                               , "ob_end_flush"+                               , "ob_flush"+                               , "ob_get_clean"+                               , "ob_get_contents"+                               , "ob_get_flush"+                               , "ob_get_length"+                               , "ob_get_level"+                               , "ob_get_status"+                               , "ob_gzhandler"+                               , "ob_iconv_handler"+                               , "ob_implicit_flush"+                               , "ob_list_handlers"+                               , "ob_start"+                               , "oci_bind_array_by_name"+                               , "oci_bind_by_name"+                               , "oci_cancel"+                               , "oci_close"+                               , "oci_commit"+                               , "oci_connect"+                               , "oci_define_by_name"+                               , "oci_error"+                               , "oci_execute"+                               , "oci_fetch"+                               , "oci_fetch_all"+                               , "oci_fetch_array"+                               , "oci_fetch_assoc"+                               , "oci_fetch_object"+                               , "oci_fetch_row"+                               , "oci_field_is_null"+                               , "oci_field_name"+                               , "oci_field_precision"+                               , "oci_field_scale"+                               , "oci_field_size"+                               , "oci_field_type"+                               , "oci_field_type_raw"+                               , "oci_free_statement"+                               , "oci_internal_debug"+                               , "oci_lob_copy"+                               , "oci_lob_is_equal"+                               , "oci_new_collection"+                               , "oci_new_connect"+                               , "oci_new_cursor"+                               , "oci_new_descriptor"+                               , "oci_num_fields"+                               , "oci_num_rows"+                               , "oci_parse"+                               , "oci_password_change"+                               , "oci_pconnect"+                               , "oci_result"+                               , "oci_rollback"+                               , "oci_server_version"+                               , "oci_set_action"+                               , "oci_set_client_identifier"+                               , "oci_set_client_info"+                               , "oci_set_edition"+                               , "oci_set_module_name"+                               , "oci_set_prefetch"+                               , "oci_statement_type"+                               , "ocibindbyname"+                               , "ocicancel"+                               , "ocicollappend"+                               , "ocicollassign"+                               , "ocicollassignelem"+                               , "ocicollgetelem"+                               , "ocicollmax"+                               , "ocicollsize"+                               , "ocicolltrim"+                               , "ocicolumnisnull"+                               , "ocicolumnname"+                               , "ocicolumnprecision"+                               , "ocicolumnscale"+                               , "ocicolumnsize"+                               , "ocicolumntype"+                               , "ocicolumntyperaw"+                               , "ocicommit"+                               , "ocidefinebyname"+                               , "ocierror"+                               , "ociexecute"+                               , "ocifetch"+                               , "ocifetchstatement"+                               , "ocifreecollection"+                               , "ocifreecursor"+                               , "ocifreedesc"+                               , "ocifreestatement"+                               , "ociinternaldebug"+                               , "ociloadlob"+                               , "ocilogoff"+                               , "ocilogon"+                               , "ocinewcollection"+                               , "ocinewcursor"+                               , "ocinewdescriptor"+                               , "ocinlogon"+                               , "ocinumcols"+                               , "ociparse"+                               , "ociplogon"+                               , "ociresult"+                               , "ocirollback"+                               , "ocirowcount"+                               , "ocisavelob"+                               , "ocisavelobfile"+                               , "ociserverversion"+                               , "ocisetprefetch"+                               , "ocistatementtype"+                               , "ociwritelobtofile"+                               , "octdec"+                               , "odbc_autocommit"+                               , "odbc_binmode"+                               , "odbc_close"+                               , "odbc_close_all"+                               , "odbc_columnprivileges"+                               , "odbc_columns"+                               , "odbc_commit"+                               , "odbc_connect"+                               , "odbc_cursor"+                               , "odbc_data_source"+                               , "odbc_do"+                               , "odbc_error"+                               , "odbc_errormsg"+                               , "odbc_exec"+                               , "odbc_execute"+                               , "odbc_fetch_array"+                               , "odbc_fetch_into"+                               , "odbc_fetch_object"+                               , "odbc_fetch_row"+                               , "odbc_field_len"+                               , "odbc_field_name"+                               , "odbc_field_num"+                               , "odbc_field_precision"+                               , "odbc_field_scale"+                               , "odbc_field_type"+                               , "odbc_foreignkeys"+                               , "odbc_free_result"+                               , "odbc_gettypeinfo"+                               , "odbc_longreadlen"+                               , "odbc_next_result"+                               , "odbc_num_fields"+                               , "odbc_num_rows"+                               , "odbc_pconnect"+                               , "odbc_prepare"+                               , "odbc_primarykeys"+                               , "odbc_procedurecolumns"+                               , "odbc_procedures"+                               , "odbc_result"+                               , "odbc_result_all"+                               , "odbc_rollback"+                               , "odbc_setoption"+                               , "odbc_specialcolumns"+                               , "odbc_statistics"+                               , "odbc_tableprivileges"+                               , "odbc_tables"+                               , "opendir"+                               , "openlog"+                               , "openssl_csr_export"+                               , "openssl_csr_export_to_file"+                               , "openssl_csr_new"+                               , "openssl_csr_sign"+                               , "openssl_error_string"+                               , "openssl_free_key"+                               , "openssl_get_privatekey"+                               , "openssl_get_publickey"+                               , "openssl_open"+                               , "openssl_pkcs7_decrypt"+                               , "openssl_pkcs7_encrypt"+                               , "openssl_pkcs7_sign"+                               , "openssl_pkcs7_verify"+                               , "openssl_pkey_export"+                               , "openssl_pkey_export_to_file"+                               , "openssl_pkey_free"+                               , "openssl_pkey_get_private"+                               , "openssl_pkey_get_public"+                               , "openssl_pkey_new"+                               , "openssl_private_decrypt"+                               , "openssl_private_encrypt"+                               , "openssl_public_decrypt"+                               , "openssl_public_encrypt"+                               , "openssl_seal"+                               , "openssl_sign"+                               , "openssl_verify"+                               , "openssl_x509_check_private_key"+                               , "openssl_x509_checkpurpose"+                               , "openssl_x509_export"+                               , "openssl_x509_export_to_file"+                               , "openssl_x509_free"+                               , "openssl_x509_parse"+                               , "openssl_x509_read"+                               , "ord"+                               , "output_add_rewrite_var"+                               , "output_reset_rewrite_vars"+                               , "overload"+                               , "ovrimos_close"+                               , "ovrimos_commit"+                               , "ovrimos_connect"+                               , "ovrimos_cursor"+                               , "ovrimos_exec"+                               , "ovrimos_execute"+                               , "ovrimos_fetch_into"+                               , "ovrimos_fetch_row"+                               , "ovrimos_field_len"+                               , "ovrimos_field_name"+                               , "ovrimos_field_num"+                               , "ovrimos_field_type"+                               , "ovrimos_free_result"+                               , "ovrimos_longreadlen"+                               , "ovrimos_num_fields"+                               , "ovrimos_num_rows"+                               , "ovrimos_prepare"+                               , "ovrimos_result"+                               , "ovrimos_result_all"+                               , "ovrimos_rollback"+                               , "pack"+                               , "parse_ini_file"+                               , "parse_ini_string"+                               , "parse_str"+                               , "parse_url"+                               , "passthru"+                               , "pathinfo"+                               , "pclose"+                               , "pcntl_alarm"+                               , "pcntl_exec"+                               , "pcntl_fork"+                               , "pcntl_getpriority"+                               , "pcntl_setpriority"+                               , "pcntl_signal"+                               , "pcntl_wait"+                               , "pcntl_waitpid"+                               , "pcntl_wexitstatus"+                               , "pcntl_wifexited"+                               , "pcntl_wifsignaled"+                               , "pcntl_wifstopped"+                               , "pcntl_wstopsig"+                               , "pcntl_wtermsig"+                               , "pdf_add_annotation"+                               , "pdf_add_bookmark"+                               , "pdf_add_launchlink"+                               , "pdf_add_locallink"+                               , "pdf_add_note"+                               , "pdf_add_outline"+                               , "pdf_add_pdflink"+                               , "pdf_add_thumbnail"+                               , "pdf_add_weblink"+                               , "pdf_arc"+                               , "pdf_arcn"+                               , "pdf_attach_file"+                               , "pdf_begin_page"+                               , "pdf_begin_pattern"+                               , "pdf_begin_template"+                               , "pdf_circle"+                               , "pdf_clip"+                               , "pdf_close"+                               , "pdf_close_image"+                               , "pdf_close_pdi"+                               , "pdf_close_pdi_page"+                               , "pdf_closepath"+                               , "pdf_closepath_fill_stroke"+                               , "pdf_closepath_stroke"+                               , "pdf_concat"+                               , "pdf_continue_text"+                               , "pdf_curveto"+                               , "pdf_delete"+                               , "pdf_end_page"+                               , "pdf_end_pattern"+                               , "pdf_end_template"+                               , "pdf_endpath"+                               , "pdf_fill"+                               , "pdf_fill_stroke"+                               , "pdf_findfont"+                               , "pdf_get_buffer"+                               , "pdf_get_font"+                               , "pdf_get_fontname"+                               , "pdf_get_fontsize"+                               , "pdf_get_image_height"+                               , "pdf_get_image_width"+                               , "pdf_get_majorversion"+                               , "pdf_get_minorversion"+                               , "pdf_get_parameter"+                               , "pdf_get_pdi_parameter"+                               , "pdf_get_pdi_value"+                               , "pdf_get_value"+                               , "pdf_initgraphics"+                               , "pdf_lineto"+                               , "pdf_makespotcolor"+                               , "pdf_moveto"+                               , "pdf_new"+                               , "pdf_open"+                               , "pdf_open_ccitt"+                               , "pdf_open_file"+                               , "pdf_open_gif"+                               , "pdf_open_image"+                               , "pdf_open_image_file"+                               , "pdf_open_jpeg"+                               , "pdf_open_memory_image"+                               , "pdf_open_pdi"+                               , "pdf_open_pdi_page"+                               , "pdf_open_png"+                               , "pdf_open_tiff"+                               , "pdf_place_image"+                               , "pdf_place_pdi_page"+                               , "pdf_rect"+                               , "pdf_restore"+                               , "pdf_rotate"+                               , "pdf_save"+                               , "pdf_scale"+                               , "pdf_set_border_color"+                               , "pdf_set_border_dash"+                               , "pdf_set_border_style"+                               , "pdf_set_char_spacing"+                               , "pdf_set_duration"+                               , "pdf_set_font"+                               , "pdf_set_horiz_scaling"+                               , "pdf_set_info"+                               , "pdf_set_info_author"+                               , "pdf_set_info_creator"+                               , "pdf_set_info_keywords"+                               , "pdf_set_info_subject"+                               , "pdf_set_info_title"+                               , "pdf_set_leading"+                               , "pdf_set_parameter"+                               , "pdf_set_text_pos"+                               , "pdf_set_text_rendering"+                               , "pdf_set_text_rise"+                               , "pdf_set_transition"+                               , "pdf_set_value"+                               , "pdf_set_word_spacing"+                               , "pdf_setcolor"+                               , "pdf_setdash"+                               , "pdf_setflat"+                               , "pdf_setfont"+                               , "pdf_setgray"+                               , "pdf_setgray_fill"+                               , "pdf_setgray_stroke"+                               , "pdf_setlinecap"+                               , "pdf_setlinejoin"+                               , "pdf_setlinewidth"+                               , "pdf_setmatrix"+                               , "pdf_setmiterlimit"+                               , "pdf_setpolydash"+                               , "pdf_setrgbcolor"+                               , "pdf_setrgbcolor_fill"+                               , "pdf_setrgbcolor_stroke"+                               , "pdf_show"+                               , "pdf_show_boxed"+                               , "pdf_show_xy"+                               , "pdf_skew"+                               , "pdf_stringwidth"+                               , "pdf_stroke"+                               , "pdf_translate"+                               , "pdo_drivers"+                               , "pfpro_cleanup"+                               , "pfpro_init"+                               , "pfpro_process"+                               , "pfpro_process_raw"+                               , "pfpro_version"+                               , "pfsockopen"+                               , "pg_affected_rows"+                               , "pg_cancel_query"+                               , "pg_client_encoding"+                               , "pg_clientencoding"+                               , "pg_close"+                               , "pg_cmdtuples"+                               , "pg_connect"+                               , "pg_connection_busy"+                               , "pg_connection_reset"+                               , "pg_connection_status"+                               , "pg_convert"+                               , "pg_copy_from"+                               , "pg_copy_to"+                               , "pg_dbname"+                               , "pg_delete"+                               , "pg_end_copy"+                               , "pg_errormessage"+                               , "pg_escape_bytea"+                               , "pg_escape_string"+                               , "pg_exec"+                               , "pg_fetch_all"+                               , "pg_fetch_array"+                               , "pg_fetch_assoc"+                               , "pg_fetch_object"+                               , "pg_fetch_result"+                               , "pg_fetch_row"+                               , "pg_field_is_null"+                               , "pg_field_name"+                               , "pg_field_num"+                               , "pg_field_prtlen"+                               , "pg_field_size"+                               , "pg_field_type"+                               , "pg_fieldisnull"+                               , "pg_fieldname"+                               , "pg_fieldnum"+                               , "pg_fieldprtlen"+                               , "pg_fieldsize"+                               , "pg_fieldtype"+                               , "pg_free_result"+                               , "pg_freeresult"+                               , "pg_get_notify"+                               , "pg_get_pid"+                               , "pg_get_result"+                               , "pg_getlastoid"+                               , "pg_host"+                               , "pg_insert"+                               , "pg_last_error"+                               , "pg_last_notice"+                               , "pg_last_oid"+                               , "pg_lo_close"+                               , "pg_lo_create"+                               , "pg_lo_export"+                               , "pg_lo_import"+                               , "pg_lo_open"+                               , "pg_lo_read"+                               , "pg_lo_read_all"+                               , "pg_lo_seek"+                               , "pg_lo_tell"+                               , "pg_lo_unlink"+                               , "pg_lo_write"+                               , "pg_loclose"+                               , "pg_locreate"+                               , "pg_loexport"+                               , "pg_loimport"+                               , "pg_loopen"+                               , "pg_loread"+                               , "pg_loreadall"+                               , "pg_lounlink"+                               , "pg_lowrite"+                               , "pg_meta_data"+                               , "pg_num_fields"+                               , "pg_num_rows"+                               , "pg_numfields"+                               , "pg_numrows"+                               , "pg_options"+                               , "pg_parameter_status"+                               , "pg_pconnect"+                               , "pg_ping"+                               , "pg_port"+                               , "pg_put_line"+                               , "pg_query"+                               , "pg_result"+                               , "pg_result_error"+                               , "pg_result_seek"+                               , "pg_result_status"+                               , "pg_select"+                               , "pg_send_query"+                               , "pg_set_client_encoding"+                               , "pg_setclientencoding"+                               , "pg_trace"+                               , "pg_tty"+                               , "pg_unescape_bytea"+                               , "pg_untrace"+                               , "pg_update"+                               , "pg_version"+                               , "php_egg_logo_guid"+                               , "php_ini_loaded_file"+                               , "php_ini_scanned_files"+                               , "php_logo_guid"+                               , "php_real_logo_guid"+                               , "php_sapi_name"+                               , "php_strip_whitespace"+                               , "php_uname"+                               , "phpcredits"+                               , "phpinfo"+                               , "phpversion"+                               , "pi"+                               , "png2wbmp"+                               , "popen"+                               , "pos"+                               , "posix_ctermid"+                               , "posix_errno"+                               , "posix_get_last_error"+                               , "posix_getcwd"+                               , "posix_getegid"+                               , "posix_geteuid"+                               , "posix_getgid"+                               , "posix_getgrgid"+                               , "posix_getgrnam"+                               , "posix_getgroups"+                               , "posix_getlogin"+                               , "posix_getpgid"+                               , "posix_getpgrp"+                               , "posix_getpid"+                               , "posix_getppid"+                               , "posix_getpwnam"+                               , "posix_getpwuid"+                               , "posix_getrlimit"+                               , "posix_getsid"+                               , "posix_getuid"+                               , "posix_isatty"+                               , "posix_kill"+                               , "posix_mkfifo"+                               , "posix_setegid"+                               , "posix_seteuid"+                               , "posix_setgid"+                               , "posix_setpgid"+                               , "posix_setsid"+                               , "posix_setuid"+                               , "posix_strerror"+                               , "posix_times"+                               , "posix_ttyname"+                               , "posix_uname"+                               , "pow"+                               , "preg_filter"+                               , "preg_grep"+                               , "preg_last_error"+                               , "preg_match"+                               , "preg_match_all"+                               , "preg_quote"+                               , "preg_replace"+                               , "preg_replace_callback"+                               , "preg_split"+                               , "prev"+                               , "print"+                               , "print_r"+                               , "printer_abort"+                               , "printer_close"+                               , "printer_create_brush"+                               , "printer_create_dc"+                               , "printer_create_font"+                               , "printer_create_pen"+                               , "printer_delete_brush"+                               , "printer_delete_dc"+                               , "printer_delete_font"+                               , "printer_delete_pen"+                               , "printer_draw_bmp"+                               , "printer_draw_chord"+                               , "printer_draw_elipse"+                               , "printer_draw_line"+                               , "printer_draw_pie"+                               , "printer_draw_rectangle"+                               , "printer_draw_roundrect"+                               , "printer_draw_text"+                               , "printer_end_doc"+                               , "printer_end_page"+                               , "printer_get_option"+                               , "printer_list"+                               , "printer_logical_fontheight"+                               , "printer_open"+                               , "printer_select_brush"+                               , "printer_select_font"+                               , "printer_select_pen"+                               , "printer_set_option"+                               , "printer_start_doc"+                               , "printer_start_page"+                               , "printer_write"+                               , "printf"+                               , "proc_close"+                               , "proc_get_status"+                               , "proc_nice"+                               , "proc_open"+                               , "proc_terminate"+                               , "property_exists"+                               , "pspell_add_to_personal"+                               , "pspell_add_to_session"+                               , "pspell_check"+                               , "pspell_clear_session"+                               , "pspell_config_create"+                               , "pspell_config_ignore"+                               , "pspell_config_mode"+                               , "pspell_config_personal"+                               , "pspell_config_repl"+                               , "pspell_config_runtogether"+                               , "pspell_config_save_repl"+                               , "pspell_new"+                               , "pspell_new_config"+                               , "pspell_new_personal"+                               , "pspell_save_wordlist"+                               , "pspell_store_replacement"+                               , "pspell_suggest"+                               , "putenv"+                               , "qdom_error"+                               , "qdom_tree"+                               , "quoted_printable_decode"+                               , "quoted_printable_encode"+                               , "quotemeta"+                               , "rad2deg"+                               , "rand"+                               , "range"+                               , "rawurldecode"+                               , "rawurlencode"+                               , "read_exif_data"+                               , "readdir"+                               , "readfile"+                               , "readgzfile"+                               , "readline"+                               , "readline_add_history"+                               , "readline_clear_history"+                               , "readline_completion_function"+                               , "readline_info"+                               , "readline_list_history"+                               , "readline_read_history"+                               , "readline_write_history"+                               , "readlink"+                               , "realpath"+                               , "realpath_cache_get"+                               , "realpath_cache_size"+                               , "recode"+                               , "recode_file"+                               , "recode_string"+                               , "register_shutdown_function"+                               , "register_tick_function"+                               , "rename"+                               , "require"+                               , "require_once"+                               , "reset"+                               , "restore_error_handler"+                               , "restore_exception_handler"+                               , "restore_include_path"+                               , "rewind"+                               , "rewinddir"+                               , "rmdir"+                               , "round"+                               , "rsort"+                               , "rtrim"+                               , "scandir"+                               , "sem_acquire"+                               , "sem_get"+                               , "sem_release"+                               , "sem_remove"+                               , "serialize"+                               , "sesam_affected_rows"+                               , "sesam_commit"+                               , "sesam_connect"+                               , "sesam_diagnostic"+                               , "sesam_disconnect"+                               , "sesam_errormsg"+                               , "sesam_execimm"+                               , "sesam_fetch_array"+                               , "sesam_fetch_result"+                               , "sesam_fetch_row"+                               , "sesam_field_array"+                               , "sesam_field_name"+                               , "sesam_free_result"+                               , "sesam_num_fields"+                               , "sesam_query"+                               , "sesam_rollback"+                               , "sesam_seek_row"+                               , "sesam_settransaction"+                               , "session_cache_expire"+                               , "session_cache_limiter"+                               , "session_commit"+                               , "session_decode"+                               , "session_destroy"+                               , "session_encode"+                               , "session_get_cookie_params"+                               , "session_id"+                               , "session_is_registered"+                               , "session_module_name"+                               , "session_name"+                               , "session_regenerate_id"+                               , "session_register"+                               , "session_save_path"+                               , "session_set_cookie_params"+                               , "session_set_save_handler"+                               , "session_start"+                               , "session_unregister"+                               , "session_unset"+                               , "session_write_close"+                               , "set_error_handler"+                               , "set_exception_handler"+                               , "set_file_buffer"+                               , "set_include_path"+                               , "set_magic_quotes_runtime"+                               , "set_socket_blocking"+                               , "set_time_limit"+                               , "setcookie"+                               , "setlocale"+                               , "setrawcookie"+                               , "settype"+                               , "sha1"+                               , "sha1_file"+                               , "sha256"+                               , "sha256_file"+                               , "shell_exec"+                               , "shm_attach"+                               , "shm_detach"+                               , "shm_get_var"+                               , "shm_put_var"+                               , "shm_remove"+                               , "shm_remove_var"+                               , "shmop_close"+                               , "shmop_delete"+                               , "shmop_open"+                               , "shmop_read"+                               , "shmop_size"+                               , "shmop_write"+                               , "show_source"+                               , "shuffle"+                               , "similar_text"+                               , "simplexml_import_dom"+                               , "simplexml_load_file"+                               , "simplexml_load_string"+                               , "sin"+                               , "sinh"+                               , "sizeof"+                               , "sleep"+                               , "snmp3_get"+                               , "snmp3_getnext"+                               , "snmp3_real_walk"+                               , "snmp3_set"+                               , "snmp3_walk"+                               , "snmp_get_quick_print"+                               , "snmp_get_valueretrieval"+                               , "snmp_read_mib"+                               , "snmp_set_enum_print"+                               , "snmp_set_oid_numeric_print"+                               , "snmp_set_quick_print"+                               , "snmp_set_valueretrieval"+                               , "snmpget"+                               , "snmpgetnext"+                               , "snmprealwalk"+                               , "snmpset"+                               , "snmpwalk"+                               , "snmpwalkoid"+                               , "socket_accept"+                               , "socket_bind"+                               , "socket_clear_error"+                               , "socket_close"+                               , "socket_connect"+                               , "socket_create"+                               , "socket_create_listen"+                               , "socket_create_pair"+                               , "socket_get_option"+                               , "socket_get_status"+                               , "socket_getopt"+                               , "socket_getpeername"+                               , "socket_getsockname"+                               , "socket_last_error"+                               , "socket_listen"+                               , "socket_read"+                               , "socket_recv"+                               , "socket_recvfrom"+                               , "socket_select"+                               , "socket_send"+                               , "socket_sendto"+                               , "socket_set_block"+                               , "socket_set_blocking"+                               , "socket_set_nonblock"+                               , "socket_set_option"+                               , "socket_set_timeout"+                               , "socket_setopt"+                               , "socket_shutdown"+                               , "socket_strerror"+                               , "socket_write"+                               , "sort"+                               , "soundex"+                               , "spl_autoload"+                               , "spl_autoload_call"+                               , "spl_autoload_extensions"+                               , "spl_autoload_functions"+                               , "spl_autoload_register"+                               , "spl_autoload_unregister"+                               , "spl_classes"+                               , "spl_object_hash"+                               , "sprintf"+                               , "sqlite_array_query"+                               , "sqlite_busy_timeout"+                               , "sqlite_changes"+                               , "sqlite_close"+                               , "sqlite_column"+                               , "sqlite_create_aggregate"+                               , "sqlite_create_function"+                               , "sqlite_current"+                               , "sqlite_error_string"+                               , "sqlite_escape_string"+                               , "sqlite_exec"+                               , "sqlite_factory"+                               , "sqlite_fetch_all"+                               , "sqlite_fetch_array"+                               , "sqlite_fetch_column_types"+                               , "sqlite_fetch_object"+                               , "sqlite_fetch_single"+                               , "sqlite_fetch_string"+                               , "sqlite_field_name"+                               , "sqlite_has_more"+                               , "sqlite_has_prev"+                               , "sqlite_last_error"+                               , "sqlite_last_insert_rowid"+                               , "sqlite_libencoding"+                               , "sqlite_libversion"+                               , "sqlite_next"+                               , "sqlite_num_fields"+                               , "sqlite_num_rows"+                               , "sqlite_open"+                               , "sqlite_popen"+                               , "sqlite_prev"+                               , "sqlite_query"+                               , "sqlite_rewind"+                               , "sqlite_seek"+                               , "sqlite_single_query"+                               , "sqlite_udf_decode_binary"+                               , "sqlite_udf_encode_binary"+                               , "sqlite_unbuffered_query"+                               , "sqlite_valid"+                               , "sqrt"+                               , "srand"+                               , "sscanf"+                               , "stat"+                               , "str_getcsv"+                               , "str_ireplace"+                               , "str_pad"+                               , "str_repeat"+                               , "str_replace"+                               , "str_rot13"+                               , "str_shuffle"+                               , "str_split"+                               , "str_word_count"+                               , "strcasecmp"+                               , "strchr"+                               , "strcmp"+                               , "strcoll"+                               , "strcspn"+                               , "stream_bucket_append"+                               , "stream_bucket_make_writeable"+                               , "stream_bucket_new"+                               , "stream_bucket_prepend"+                               , "stream_context_create"+                               , "stream_context_get_default"+                               , "stream_context_get_options"+                               , "stream_context_get_params"+                               , "stream_context_set_default"+                               , "stream_context_set_option"+                               , "stream_context_set_params"+                               , "stream_copy_to_stream"+                               , "stream_filter_append"+                               , "stream_filter_prepend"+                               , "stream_filter_register"+                               , "stream_filter_remove"+                               , "stream_get_contents"+                               , "stream_get_filters"+                               , "stream_get_line"+                               , "stream_get_meta_data"+                               , "stream_get_transports"+                               , "stream_get_wrappers"+                               , "stream_is_local"+                               , "stream_register_wrapper"+                               , "stream_resolve_include_path"+                               , "stream_select"+                               , "stream_set_blocking"+                               , "stream_set_read_buffer"+                               , "stream_set_timeout"+                               , "stream_set_write_buffer"+                               , "stream_socket_accept"+                               , "stream_socket_client"+                               , "stream_socket_enable_crypto"+                               , "stream_socket_get_name"+                               , "stream_socket_pair"+                               , "stream_socket_recvfrom"+                               , "stream_socket_sendto"+                               , "stream_socket_server"+                               , "stream_socket_shutdown"+                               , "stream_supports_lock"+                               , "stream_wrapper_register"+                               , "stream_wrapper_restore"+                               , "stream_wrapper_unregister"+                               , "strftime"+                               , "strip_tags"+                               , "stripcslashes"+                               , "stripos"+                               , "stripslashes"+                               , "stristr"+                               , "strlen"+                               , "strnatcasecmp"+                               , "strnatcmp"+                               , "strncasecmp"+                               , "strncmp"+                               , "strpbrk"+                               , "strpos"+                               , "strptime"+                               , "strrchr"+                               , "strrev"+                               , "strripos"+                               , "strrpos"+                               , "strspn"+                               , "strstr"+                               , "strtok"+                               , "strtolower"+                               , "strtotime"+                               , "strtoupper"+                               , "strtr"+                               , "strval"+                               , "substr"+                               , "substr_compare"+                               , "substr_count"+                               , "substr_replace"+                               , "suhosin_encrypt_cookie"+                               , "suhosin_get_raw_cookies"+                               , "swf_actiongeturl"+                               , "swf_actiongotoframe"+                               , "swf_actiongotolabel"+                               , "swf_actionnextframe"+                               , "swf_actionplay"+                               , "swf_actionprevframe"+                               , "swf_actionsettarget"+                               , "swf_actionstop"+                               , "swf_actiontogglequality"+                               , "swf_actionwaitforframe"+                               , "swf_addbuttonrecord"+                               , "swf_addcolor"+                               , "swf_closefile"+                               , "swf_definebitmap"+                               , "swf_definefont"+                               , "swf_defineline"+                               , "swf_definepoly"+                               , "swf_definerect"+                               , "swf_definetext"+                               , "swf_endbutton"+                               , "swf_enddoaction"+                               , "swf_endshape"+                               , "swf_endsymbol"+                               , "swf_fontsize"+                               , "swf_fontslant"+                               , "swf_fonttracking"+                               , "swf_getbitmapinfo"+                               , "swf_getfontinfo"+                               , "swf_getframe"+                               , "swf_labelframe"+                               , "swf_lookat"+                               , "swf_modifyobject"+                               , "swf_mulcolor"+                               , "swf_nextid"+                               , "swf_oncondition"+                               , "swf_openfile"+                               , "swf_ortho"+                               , "swf_ortho2"+                               , "swf_perspective"+                               , "swf_placeobject"+                               , "swf_polarview"+                               , "swf_popmatrix"+                               , "swf_posround"+                               , "swf_pushmatrix"+                               , "swf_removeobject"+                               , "swf_rotate"+                               , "swf_scale"+                               , "swf_setfont"+                               , "swf_setframe"+                               , "swf_shapearc"+                               , "swf_shapecurveto"+                               , "swf_shapecurveto3"+                               , "swf_shapefillbitmapclip"+                               , "swf_shapefillbitmaptile"+                               , "swf_shapefilloff"+                               , "swf_shapefillsolid"+                               , "swf_shapelinesolid"+                               , "swf_shapelineto"+                               , "swf_shapemoveto"+                               , "swf_showframe"+                               , "swf_startbutton"+                               , "swf_startdoaction"+                               , "swf_startshape"+                               , "swf_startsymbol"+                               , "swf_textwidth"+                               , "swf_translate"+                               , "swf_viewport"+                               , "swfaction"+                               , "swfbitmap"+                               , "swfbitmap.getheight"+                               , "swfbitmap.getwidth"+                               , "swfbutton"+                               , "swfbutton.addaction"+                               , "swfbutton.addshape"+                               , "swfbutton.setaction"+                               , "swfbutton.setdown"+                               , "swfbutton.sethit"+                               , "swfbutton.setover"+                               , "swfbutton.setup"+                               , "swfbutton_keypress"+                               , "swfdisplayitem"+                               , "swfdisplayitem.addcolor"+                               , "swfdisplayitem.move"+                               , "swfdisplayitem.moveto"+                               , "swfdisplayitem.multcolor"+                               , "swfdisplayitem.remove"+                               , "swfdisplayitem.rotate"+                               , "swfdisplayitem.rotateto"+                               , "swfdisplayitem.scale"+                               , "swfdisplayitem.scaleto"+                               , "swfdisplayitem.setdepth"+                               , "swfdisplayitem.setname"+                               , "swfdisplayitem.setratio"+                               , "swfdisplayitem.skewx"+                               , "swfdisplayitem.skewxto"+                               , "swfdisplayitem.skewy"+                               , "swfdisplayitem.skewyto"+                               , "swffill"+                               , "swffill.moveto"+                               , "swffill.rotateto"+                               , "swffill.scaleto"+                               , "swffill.skewxto"+                               , "swffill.skewyto"+                               , "swffont"+                               , "swffont.getwidth"+                               , "swfgradient"+                               , "swfgradient.addentry"+                               , "swfmorph"+                               , "swfmorph.getshape1"+                               , "swfmorph.getshape2"+                               , "swfmovie"+                               , "swfmovie.add"+                               , "swfmovie.nextframe"+                               , "swfmovie.output"+                               , "swfmovie.remove"+                               , "swfmovie.save"+                               , "swfmovie.setbackground"+                               , "swfmovie.setdimension"+                               , "swfmovie.setframes"+                               , "swfmovie.setrate"+                               , "swfmovie.streammp3"+                               , "swfshape"+                               , "swfshape.addfill"+                               , "swfshape.drawcurve"+                               , "swfshape.drawcurveto"+                               , "swfshape.drawline"+                               , "swfshape.drawlineto"+                               , "swfshape.movepen"+                               , "swfshape.movepento"+                               , "swfshape.setleftfill"+                               , "swfshape.setline"+                               , "swfshape.setrightfill"+                               , "swfsprite"+                               , "swfsprite.add"+                               , "swfsprite.nextframe"+                               , "swfsprite.remove"+                               , "swfsprite.setframes"+                               , "swftext"+                               , "swftext.addstring"+                               , "swftext.getwidth"+                               , "swftext.moveto"+                               , "swftext.setcolor"+                               , "swftext.setfont"+                               , "swftext.setheight"+                               , "swftext.setspacing"+                               , "swftextfield"+                               , "swftextfield.addstring"+                               , "swftextfield.align"+                               , "swftextfield.setbounds"+                               , "swftextfield.setcolor"+                               , "swftextfield.setfont"+                               , "swftextfield.setheight"+                               , "swftextfield.setindentation"+                               , "swftextfield.setleftmargin"+                               , "swftextfield.setlinespacing"+                               , "swftextfield.setmargins"+                               , "swftextfield.setname"+                               , "swftextfield.setrightmargin"+                               , "sybase_affected_rows"+                               , "sybase_close"+                               , "sybase_connect"+                               , "sybase_data_seek"+                               , "sybase_fetch_array"+                               , "sybase_fetch_field"+                               , "sybase_fetch_object"+                               , "sybase_fetch_row"+                               , "sybase_field_seek"+                               , "sybase_free_result"+                               , "sybase_get_last_message"+                               , "sybase_min_client_severity"+                               , "sybase_min_error_severity"+                               , "sybase_min_message_severity"+                               , "sybase_min_server_severity"+                               , "sybase_num_fields"+                               , "sybase_num_rows"+                               , "sybase_pconnect"+                               , "sybase_query"+                               , "sybase_result"+                               , "sybase_select_db"+                               , "symlink"+                               , "sys_get_temp_dir"+                               , "sys_getloadavg"+                               , "syslog"+                               , "system"+                               , "tan"+                               , "tanh"+                               , "tempnam"+                               , "textdomain"+                               , "time"+                               , "time_nanosleep"+                               , "time_sleep_until"+                               , "timezone_abbreviations_list"+                               , "timezone_identifiers_list"+                               , "timezone_location_get"+                               , "timezone_name_from_abbr"+                               , "timezone_name_get"+                               , "timezone_offset_get"+                               , "timezone_open"+                               , "timezone_transitions_get"+                               , "timezone_version_get"+                               , "tmpfile"+                               , "token_get_all"+                               , "token_name"+                               , "touch"+                               , "trigger_error"+                               , "trim"+                               , "uasort"+                               , "ucfirst"+                               , "ucwords"+                               , "udm_add_search_limit"+                               , "udm_alloc_agent"+                               , "udm_api_version"+                               , "udm_cat_list"+                               , "udm_cat_path"+                               , "udm_check_charset"+                               , "udm_check_stored"+                               , "udm_clear_search_limits"+                               , "udm_close_stored"+                               , "udm_crc32"+                               , "udm_errno"+                               , "udm_error"+                               , "udm_find"+                               , "udm_free_agent"+                               , "udm_free_ispell_data"+                               , "udm_free_res"+                               , "udm_get_doc_count"+                               , "udm_get_res_field"+                               , "udm_get_res_param"+                               , "udm_load_ispell_data"+                               , "udm_open_stored"+                               , "udm_set_agent_param"+                               , "uksort"+                               , "umask"+                               , "uniqid"+                               , "unixtojd"+                               , "unlink"+                               , "unpack"+                               , "unregister_tick_function"+                               , "unserialize"+                               , "unset"+                               , "urldecode"+                               , "urlencode"+                               , "use_soap_error_handler"+                               , "user_error"+                               , "usleep"+                               , "usort"+                               , "utf8_decode"+                               , "utf8_encode"+                               , "var_dump"+                               , "var_export"+                               , "variant"+                               , "version_compare"+                               , "vfprintf"+                               , "virtual"+                               , "vpopmail_add_alias_domain"+                               , "vpopmail_add_alias_domain_ex"+                               , "vpopmail_add_domain"+                               , "vpopmail_add_domain_ex"+                               , "vpopmail_add_user"+                               , "vpopmail_alias_add"+                               , "vpopmail_alias_del"+                               , "vpopmail_alias_del_domain"+                               , "vpopmail_alias_get"+                               , "vpopmail_alias_get_all"+                               , "vpopmail_auth_user"+                               , "vpopmail_del_domain"+                               , "vpopmail_del_domain_ex"+                               , "vpopmail_del_user"+                               , "vpopmail_error"+                               , "vpopmail_passwd"+                               , "vpopmail_set_user_quota"+                               , "vprintf"+                               , "vsprintf"+                               , "w32api_deftype"+                               , "w32api_init_dtype"+                               , "w32api_invoke_function"+                               , "w32api_register_function"+                               , "w32api_set_call_method"+                               , "wddx_add_vars"+                               , "wddx_deserialize"+                               , "wddx_packet_end"+                               , "wddx_packet_start"+                               , "wddx_serialize_value"+                               , "wddx_serialize_vars"+                               , "wordwrap"+                               , "xdebug_break"+                               , "xdebug_call_class"+                               , "xdebug_call_file"+                               , "xdebug_call_function"+                               , "xdebug_call_line"+                               , "xdebug_clear_aggr_profiling_data"+                               , "xdebug_debug_zval"+                               , "xdebug_debug_zval_stdout"+                               , "xdebug_disable"+                               , "xdebug_dump_aggr_profiling_data"+                               , "xdebug_dump_superglobals"+                               , "xdebug_enable"+                               , "xdebug_get_code_coverage"+                               , "xdebug_get_collected_errors"+                               , "xdebug_get_declared_vars"+                               , "xdebug_get_formatted_function_stack"+                               , "xdebug_get_function_count"+                               , "xdebug_get_function_stack"+                               , "xdebug_get_headers"+                               , "xdebug_get_profiler_filename"+                               , "xdebug_get_stack_depth"+                               , "xdebug_get_tracefile_name"+                               , "xdebug_is_enabled"+                               , "xdebug_memory_usage"+                               , "xdebug_peak_memory_usage"+                               , "xdebug_print_function_stack"+                               , "xdebug_start_code_coverage"+                               , "xdebug_start_error_collection"+                               , "xdebug_start_trace"+                               , "xdebug_stop_code_coverage"+                               , "xdebug_stop_error_collection"+                               , "xdebug_stop_trace"+                               , "xdebug_time_index"+                               , "xdebug_var_dump"+                               , "xml_error_string"+                               , "xml_get_current_byte_index"+                               , "xml_get_current_column_number"+                               , "xml_get_current_line_number"+                               , "xml_get_error_code"+                               , "xml_parse"+                               , "xml_parse_into_struct"+                               , "xml_parser_create"+                               , "xml_parser_create_ns"+                               , "xml_parser_free"+                               , "xml_parser_get_option"+                               , "xml_parser_set_option"+                               , "xml_set_character_data_handler"+                               , "xml_set_default_handler"+                               , "xml_set_element_handler"+                               , "xml_set_end_namespace_decl_handler"+                               , "xml_set_external_entity_ref_handler"+                               , "xml_set_notation_decl_handler"+                               , "xml_set_object"+                               , "xml_set_processing_instruction_handler"+                               , "xml_set_start_namespace_decl_handler"+                               , "xml_set_unparsed_entity_decl_handler"+                               , "xmldoc"+                               , "xmldocfile"+                               , "xmlrpc_decode"+                               , "xmlrpc_decode_request"+                               , "xmlrpc_encode"+                               , "xmlrpc_encode_request"+                               , "xmlrpc_get_type"+                               , "xmlrpc_is_fault"+                               , "xmlrpc_parse_method_descriptions"+                               , "xmlrpc_server_add_introspection_data"+                               , "xmlrpc_server_call_method"+                               , "xmlrpc_server_create"+                               , "xmlrpc_server_destroy"+                               , "xmlrpc_server_register_introspection_callback"+                               , "xmlrpc_server_register_method"+                               , "xmlrpc_set_type"+                               , "xmltree"+                               , "xmlwriter_end_attribute"+                               , "xmlwriter_end_cdata"+                               , "xmlwriter_end_comment"+                               , "xmlwriter_end_document"+                               , "xmlwriter_end_dtd"+                               , "xmlwriter_end_dtd_attlist"+                               , "xmlwriter_end_dtd_element"+                               , "xmlwriter_end_dtd_entity"+                               , "xmlwriter_end_element"+                               , "xmlwriter_end_pi"+                               , "xmlwriter_flush"+                               , "xmlwriter_full_end_element"+                               , "xmlwriter_open_memory"+                               , "xmlwriter_open_uri"+                               , "xmlwriter_output_memory"+                               , "xmlwriter_set_indent"+                               , "xmlwriter_set_indent_string"+                               , "xmlwriter_start_attribute"+                               , "xmlwriter_start_attribute_ns"+                               , "xmlwriter_start_cdata"+                               , "xmlwriter_start_comment"+                               , "xmlwriter_start_document"+                               , "xmlwriter_start_dtd"+                               , "xmlwriter_start_dtd_attlist"+                               , "xmlwriter_start_dtd_element"+                               , "xmlwriter_start_dtd_entity"+                               , "xmlwriter_start_element"+                               , "xmlwriter_start_element_ns"+                               , "xmlwriter_start_pi"+                               , "xmlwriter_text"+                               , "xmlwriter_write_attribute"+                               , "xmlwriter_write_attribute_ns"+                               , "xmlwriter_write_cdata"+                               , "xmlwriter_write_comment"+                               , "xmlwriter_write_dtd"+                               , "xmlwriter_write_dtd_attlist"+                               , "xmlwriter_write_dtd_element"+                               , "xmlwriter_write_dtd_entity"+                               , "xmlwriter_write_element"+                               , "xmlwriter_write_element_ns"+                               , "xmlwriter_write_pi"+                               , "xmlwriter_write_raw"+                               , "xpath_eval"+                               , "xpath_eval_expression"+                               , "xpath_new_context"+                               , "xptr_eval"+                               , "xptr_new_context"+                               , "xslt_create"+                               , "xslt_errno"+                               , "xslt_error"+                               , "xslt_free"+                               , "xslt_process"+                               , "xslt_set_base"+                               , "xslt_set_encoding"+                               , "xslt_set_error_handler"+                               , "xslt_set_log"+                               , "xslt_set_sax_handler"+                               , "xslt_set_sax_handlers"+                               , "xslt_set_scheme_handler"+                               , "xslt_set_scheme_handlers"+                               , "yaz_addinfo"+                               , "yaz_ccl_conf"+                               , "yaz_ccl_parse"+                               , "yaz_close"+                               , "yaz_connect"+                               , "yaz_database"+                               , "yaz_element"+                               , "yaz_errno"+                               , "yaz_error"+                               , "yaz_hits"+                               , "yaz_itemorder"+                               , "yaz_present"+                               , "yaz_range"+                               , "yaz_record"+                               , "yaz_scan"+                               , "yaz_scan_result"+                               , "yaz_search"+                               , "yaz_sort"+                               , "yaz_syntax"+                               , "yaz_wait"+                               , "yp_all"+                               , "yp_cat"+                               , "yp_err_string"+                               , "yp_errno"+                               , "yp_first"+                               , "yp_get_default_domain"+                               , "yp_master"+                               , "yp_match"+                               , "yp_next"+                               , "yp_order"+                               , "zend_logo_guid"+                               , "zend_version"+                               , "zip_close"+                               , "zip_entry_close"+                               , "zip_entry_compressedsize"+                               , "zip_entry_compressionmethod"+                               , "zip_entry_filesize"+                               , "zip_entry_name"+                               , "zip_entry_open"+                               , "zip_entry_read"+                               , "zip_open"+                               , "zip_read"+                               , "zlib_get_coding_type"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?@[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "__autoload"+                               , "__call"+                               , "__clone"+                               , "__construct"+                               , "__destruct"+                               , "__get"+                               , "__halt_compiler"+                               , "__isset"+                               , "__set"+                               , "__set_state"+                               , "__sleep"+                               , "__toString"+                               , "__unset"+                               , "__wakeup"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?@[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "__CLASS__"+                               , "__COMPILER_HALT_OFFSET__"+                               , "__DIR__"+                               , "__FILE__"+                               , "__FUNCTION__"+                               , "__LINE__"+                               , "__METHOD__"+                               , "__NAMESPACE__"+                               , "__TRAIT__"+                               , "ABDAY_1"+                               , "ABDAY_2"+                               , "ABDAY_3"+                               , "ABDAY_4"+                               , "ABDAY_5"+                               , "ABDAY_6"+                               , "ABDAY_7"+                               , "ABMON_1"+                               , "ABMON_10"+                               , "ABMON_11"+                               , "ABMON_12"+                               , "ABMON_2"+                               , "ABMON_3"+                               , "ABMON_4"+                               , "ABMON_5"+                               , "ABMON_6"+                               , "ABMON_7"+                               , "ABMON_8"+                               , "ABMON_9"+                               , "AF_INET"+                               , "AF_INET6"+                               , "AF_UNIX"+                               , "ALT_DIGITS"+                               , "AM_STR"+                               , "ASSERT_ACTIVE"+                               , "ASSERT_BAIL"+                               , "ASSERT_CALLBACK"+                               , "ASSERT_QUIET_EVAL"+                               , "ASSERT_WARNING"+                               , "C_EXPLICIT_ABSTRACT"+                               , "C_FINAL"+                               , "C_IMPLICIT_ABSTRACT"+                               , "CAL_DOW_DAYNO"+                               , "CAL_DOW_LONG"+                               , "CAL_DOW_SHORT"+                               , "CAL_EASTER_ALWAYS_GREGORIAN"+                               , "CAL_EASTER_ALWAYS_JULIAN"+                               , "CAL_EASTER_DEFAULT"+                               , "CAL_EASTER_ROMAN"+                               , "CAL_FRENCH"+                               , "CAL_GREGORIAN"+                               , "CAL_JEWISH"+                               , "CAL_JEWISH_ADD_ALAFIM"+                               , "CAL_JEWISH_ADD_ALAFIM_GERESH"+                               , "CAL_JEWISH_ADD_GERESHAYIM"+                               , "CAL_JULIAN"+                               , "CAL_MONTH_FRENCH"+                               , "CAL_MONTH_GREGORIAN_LONG"+                               , "CAL_MONTH_GREGORIAN_SHORT"+                               , "CAL_MONTH_JEWISH"+                               , "CAL_MONTH_JULIAN_LONG"+                               , "CAL_MONTH_JULIAN_SHORT"+                               , "CAL_NUM_CALS"+                               , "CASE_LOWER"+                               , "CASE_UPPER"+                               , "CHAR_MAX"+                               , "CIT_CALL_TOSTRING"+                               , "CIT_CATCH_GET_CHILD"+                               , "CL_EXPUNGE"+                               , "CODESET"+                               , "CONNECTION_ABORTED"+                               , "CONNECTION_NORMAL"+                               , "CONNECTION_TIMEOUT"+                               , "COUNT_NORMAL"+                               , "COUNT_RECURSIVE"+                               , "CP_MOVE"+                               , "CP_UID"+                               , "CREDITS_ALL"+                               , "CREDITS_DOCS"+                               , "CREDITS_FULLPAGE"+                               , "CREDITS_GENERAL"+                               , "CREDITS_GROUP"+                               , "CREDITS_MODULES"+                               , "CREDITS_QA"+                               , "CREDITS_SAPI"+                               , "CRNCYSTR"+                               , "CRYPT_BLOWFISH"+                               , "CRYPT_EXT_DES"+                               , "CRYPT_MD5"+                               , "CRYPT_SALT_LENGTH"+                               , "CRYPT_STD_DES"+                               , "CURL_HTTP_VERSION_1_0"+                               , "CURL_HTTP_VERSION_1_1"+                               , "CURL_HTTP_VERSION_NONE"+                               , "CURL_NETRC_IGNORED"+                               , "CURL_NETRC_OPTIONAL"+                               , "CURL_NETRC_REQUIRED"+                               , "CURL_TIMECOND_IFMODSINCE"+                               , "CURL_TIMECOND_IFUNMODSINCE"+                               , "CURL_TIMECOND_LASTMOD"+                               , "CURL_VERSION_IPV6"+                               , "CURL_VERSION_KERBEROS4"+                               , "CURL_VERSION_LIBZ"+                               , "CURL_VERSION_SSL"+                               , "CURLAUTH_ANY"+                               , "CURLAUTH_ANYSAFE"+                               , "CURLAUTH_BASIC"+                               , "CURLAUTH_DIGEST"+                               , "CURLAUTH_GSSNEGOTIATE"+                               , "CURLAUTH_NTLM"+                               , "CURLCLOSEPOLICY_CALLBACK"+                               , "CURLCLOSEPOLICY_LEAST_RECENTLY_USED"+                               , "CURLCLOSEPOLICY_LEAST_TRAFFIC"+                               , "CURLCLOSEPOLICY_OLDEST"+                               , "CURLCLOSEPOLICY_SLOWEST"+                               , "CURLE_ABORTED_BY_CALLBACK"+                               , "CURLE_BAD_CALLING_ORDER"+                               , "CURLE_BAD_CONTENT_ENCODING"+                               , "CURLE_BAD_FUNCTION_ARGUMENT"+                               , "CURLE_BAD_PASSWORD_ENTERED"+                               , "CURLE_COULDNT_CONNECT"+                               , "CURLE_COULDNT_RESOLVE_HOST"+                               , "CURLE_COULDNT_RESOLVE_PROXY"+                               , "CURLE_FAILED_INIT"+                               , "CURLE_FILE_COULDNT_READ_FILE"+                               , "CURLE_FTP_ACCESS_DENIED"+                               , "CURLE_FTP_BAD_DOWNLOAD_RESUME"+                               , "CURLE_FTP_CANT_GET_HOST"+                               , "CURLE_FTP_CANT_RECONNECT"+                               , "CURLE_FTP_COULDNT_GET_SIZE"+                               , "CURLE_FTP_COULDNT_RETR_FILE"+                               , "CURLE_FTP_COULDNT_SET_ASCII"+                               , "CURLE_FTP_COULDNT_SET_BINARY"+                               , "CURLE_FTP_COULDNT_STOR_FILE"+                               , "CURLE_FTP_COULDNT_USE_REST"+                               , "CURLE_FTP_PORT_FAILED"+                               , "CURLE_FTP_QUOTE_ERROR"+                               , "CURLE_FTP_USER_PASSWORD_INCORRECT"+                               , "CURLE_FTP_WEIRD_227_FORMAT"+                               , "CURLE_FTP_WEIRD_PASS_REPLY"+                               , "CURLE_FTP_WEIRD_PASV_REPLY"+                               , "CURLE_FTP_WEIRD_SERVER_REPLY"+                               , "CURLE_FTP_WEIRD_USER_REPLY"+                               , "CURLE_FTP_WRITE_ERROR"+                               , "CURLE_FUNCTION_NOT_FOUND"+                               , "CURLE_GOT_NOTHING"+                               , "CURLE_HTTP_NOT_FOUND"+                               , "CURLE_HTTP_PORT_FAILED"+                               , "CURLE_HTTP_POST_ERROR"+                               , "CURLE_HTTP_RANGE_ERROR"+                               , "CURLE_LDAP_CANNOT_BIND"+                               , "CURLE_LDAP_SEARCH_FAILED"+                               , "CURLE_LIBRARY_NOT_FOUND"+                               , "CURLE_MALFORMAT_USER"+                               , "CURLE_OBSOLETE"+                               , "CURLE_OK"+                               , "CURLE_OPERATION_TIMEOUTED"+                               , "CURLE_OUT_OF_MEMORY"+                               , "CURLE_PARTIAL_FILE"+                               , "CURLE_READ_ERROR"+                               , "CURLE_RECV_ERROR"+                               , "CURLE_SEND_ERROR"+                               , "CURLE_SHARE_IN_USE"+                               , "CURLE_SSL_CACERT"+                               , "CURLE_SSL_CERTPROBLEM"+                               , "CURLE_SSL_CIPHER"+                               , "CURLE_SSL_CONNECT_ERROR"+                               , "CURLE_SSL_ENGINE_NOTFOUND"+                               , "CURLE_SSL_ENGINE_SETFAILED"+                               , "CURLE_SSL_PEER_CERTIFICATE"+                               , "CURLE_TELNET_OPTION_SYNTAX"+                               , "CURLE_TOO_MANY_REDIRECTS"+                               , "CURLE_UNKNOWN_TELNET_OPTION"+                               , "CURLE_UNSUPPORTED_PROTOCOL"+                               , "CURLE_URL_MALFORMAT"+                               , "CURLE_URL_MALFORMAT_USER"+                               , "CURLE_WRITE_ERROR"+                               , "CURLINFO_CONNECT_TIME"+                               , "CURLINFO_CONTENT_LENGTH_DOWNLOAD"+                               , "CURLINFO_CONTENT_LENGTH_UPLOAD"+                               , "CURLINFO_CONTENT_TYPE"+                               , "CURLINFO_EFFECTIVE_URL"+                               , "CURLINFO_FILETIME"+                               , "CURLINFO_HEADER_OUT"+                               , "CURLINFO_HEADER_SIZE"+                               , "CURLINFO_HTTP_CODE"+                               , "CURLINFO_NAMELOOKUP_TIME"+                               , "CURLINFO_PRETRANSFER_TIME"+                               , "CURLINFO_REDIRECT_COUNT"+                               , "CURLINFO_REDIRECT_TIME"+                               , "CURLINFO_REQUEST_SIZE"+                               , "CURLINFO_SIZE_DOWNLOAD"+                               , "CURLINFO_SIZE_UPLOAD"+                               , "CURLINFO_SPEED_DOWNLOAD"+                               , "CURLINFO_SPEED_UPLOAD"+                               , "CURLINFO_SSL_VERIFYRESULT"+                               , "CURLINFO_STARTTRANSFER_TIME"+                               , "CURLINFO_TOTAL_TIME"+                               , "CURLM_BAD_EASY_HANDLE"+                               , "CURLM_BAD_HANDLE"+                               , "CURLM_CALL_MULTI_PERFORM"+                               , "CURLM_INTERNAL_ERROR"+                               , "CURLM_OK"+                               , "CURLM_OUT_OF_MEMORY"+                               , "CURLMSG_DONE"+                               , "CURLOPT_BINARYTRANSFER"+                               , "CURLOPT_BUFFERSIZE"+                               , "CURLOPT_CAINFO"+                               , "CURLOPT_CAPATH"+                               , "CURLOPT_CLOSEPOLICY"+                               , "CURLOPT_CONNECTTIMEOUT"+                               , "CURLOPT_COOKIE"+                               , "CURLOPT_COOKIEFILE"+                               , "CURLOPT_COOKIEJAR"+                               , "CURLOPT_CRLF"+                               , "CURLOPT_CUSTOMREQUEST"+                               , "CURLOPT_DNS_CACHE_TIMEOUT"+                               , "CURLOPT_DNS_USE_GLOBAL_CACHE"+                               , "CURLOPT_EGDSOCKET"+                               , "CURLOPT_ENCODING"+                               , "CURLOPT_FAILONERROR"+                               , "CURLOPT_FILE"+                               , "CURLOPT_FILETIME"+                               , "CURLOPT_FOLLOWLOCATION"+                               , "CURLOPT_FORBID_REUSE"+                               , "CURLOPT_FRESH_CONNECT"+                               , "CURLOPT_FTP_USE_EPRT"+                               , "CURLOPT_FTP_USE_EPSV"+                               , "CURLOPT_FTPAPPEND"+                               , "CURLOPT_FTPASCII"+                               , "CURLOPT_FTPLISTONLY"+                               , "CURLOPT_FTPPORT"+                               , "CURLOPT_HEADER"+                               , "CURLOPT_HEADERFUNCTION"+                               , "CURLOPT_HTTP200ALIASES"+                               , "CURLOPT_HTTP_VERSION"+                               , "CURLOPT_HTTPAUTH"+                               , "CURLOPT_HTTPGET"+                               , "CURLOPT_HTTPHEADER"+                               , "CURLOPT_HTTPPROXYTUNNEL"+                               , "CURLOPT_INFILE"+                               , "CURLOPT_INFILESIZE"+                               , "CURLOPT_INTERFACE"+                               , "CURLOPT_KRB4LEVEL"+                               , "CURLOPT_LOW_SPEED_LIMIT"+                               , "CURLOPT_LOW_SPEED_TIME"+                               , "CURLOPT_MAXCONNECTS"+                               , "CURLOPT_MAXREDIRS"+                               , "CURLOPT_MUTE"+                               , "CURLOPT_NETRC"+                               , "CURLOPT_NOBODY"+                               , "CURLOPT_NOPROGRESS"+                               , "CURLOPT_NOSIGNAL"+                               , "CURLOPT_PASSWDFUNCTION"+                               , "CURLOPT_PORT"+                               , "CURLOPT_POST"+                               , "CURLOPT_POSTFIELDS"+                               , "CURLOPT_POSTQUOTE"+                               , "CURLOPT_PROXY"+                               , "CURLOPT_PROXYAUTH"+                               , "CURLOPT_PROXYPORT"+                               , "CURLOPT_PROXYTYPE"+                               , "CURLOPT_PROXYUSERPWD"+                               , "CURLOPT_PUT"+                               , "CURLOPT_QUOTE"+                               , "CURLOPT_RANDOM_FILE"+                               , "CURLOPT_RANGE"+                               , "CURLOPT_READDATA"+                               , "CURLOPT_READFUNCTION"+                               , "CURLOPT_REFERER"+                               , "CURLOPT_RESUME_FROM"+                               , "CURLOPT_RETURNTRANSFER"+                               , "CURLOPT_SSL_CIPHER_LIST"+                               , "CURLOPT_SSL_VERIFYHOST"+                               , "CURLOPT_SSL_VERIFYPEER"+                               , "CURLOPT_SSLCERT"+                               , "CURLOPT_SSLCERTPASSWD"+                               , "CURLOPT_SSLCERTTYPE"+                               , "CURLOPT_SSLENGINE"+                               , "CURLOPT_SSLENGINE_DEFAULT"+                               , "CURLOPT_SSLKEY"+                               , "CURLOPT_SSLKEYPASSWD"+                               , "CURLOPT_SSLKEYTYPE"+                               , "CURLOPT_SSLVERSION"+                               , "CURLOPT_STDERR"+                               , "CURLOPT_TIMECONDITION"+                               , "CURLOPT_TIMEOUT"+                               , "CURLOPT_TIMEVALUE"+                               , "CURLOPT_TRANSFERTEXT"+                               , "CURLOPT_UNRESTRICTED_AUTH"+                               , "CURLOPT_UPLOAD"+                               , "CURLOPT_URL"+                               , "CURLOPT_USERAGENT"+                               , "CURLOPT_USERPWD"+                               , "CURLOPT_VERBOSE"+                               , "CURLOPT_WRITEFUNCTION"+                               , "CURLOPT_WRITEHEADER"+                               , "CURLPROXY_HTTP"+                               , "CURLPROXY_SOCKS5"+                               , "CURLVERSION_NOW"+                               , "D_FMT"+                               , "D_T_FMT"+                               , "DATE_ATOM"+                               , "DATE_COOKIE"+                               , "DATE_ISO8601"+                               , "DATE_RFC1036"+                               , "DATE_RFC1123"+                               , "DATE_RFC2822"+                               , "DATE_RFC3339"+                               , "DATE_RFC822"+                               , "DATE_RFC850"+                               , "DATE_RSS"+                               , "DATE_W3C"+                               , "DAY_1"+                               , "DAY_2"+                               , "DAY_3"+                               , "DAY_4"+                               , "DAY_5"+                               , "DAY_6"+                               , "DAY_7"+                               , "DBX_CMP_ASC"+                               , "DBX_CMP_DESC"+                               , "DBX_CMP_NATIVE"+                               , "DBX_CMP_NUMBER"+                               , "DBX_CMP_TEXT"+                               , "DBX_COLNAMES_LOWERCASE"+                               , "DBX_COLNAMES_UNCHANGED"+                               , "DBX_COLNAMES_UPPERCASE"+                               , "DBX_FBSQL"+                               , "DBX_MSSQL"+                               , "DBX_MYSQL"+                               , "DBX_OCI8"+                               , "DBX_ODBC"+                               , "DBX_PERSISTENT"+                               , "DBX_PGSQL"+                               , "DBX_RESULT_ASSOC"+                               , "DBX_RESULT_INDEX"+                               , "DBX_RESULT_INFO"+                               , "DBX_RESULT_UNBUFFERED"+                               , "DBX_SQLITE"+                               , "DBX_SYBASECT"+                               , "DEFAULT_INCLUDE_PATH"+                               , "DIRECTORY_SEPARATOR"+                               , "DNS_A"+                               , "DNS_AAAA"+                               , "DNS_ALL"+                               , "DNS_ANY"+                               , "DNS_CNAME"+                               , "DNS_HINFO"+                               , "DNS_MX"+                               , "DNS_NAPTR"+                               , "DNS_NS"+                               , "DNS_PTR"+                               , "DNS_SOA"+                               , "DNS_SRV"+                               , "DNS_TXT"+                               , "DOM_HIERARCHY_REQUEST_ERR"+                               , "DOM_INDEX_SIZE_ERR"+                               , "DOM_INUSE_ATTRIBUTE_ERR"+                               , "DOM_INVALID_ACCESS_ERR"+                               , "DOM_INVALID_CHARACTER_ERR"+                               , "DOM_INVALID_MODIFICATION_ERR"+                               , "DOM_INVALID_STATE_ERR"+                               , "DOM_NAMESPACE_ERR"+                               , "DOM_NO_DATA_ALLOWED_ERR"+                               , "DOM_NO_MODIFICATION_ALLOWED_ERR"+                               , "DOM_NOT_FOUND_ERR"+                               , "DOM_NOT_SUPPORTED_ERR"+                               , "DOM_PHP_ERR"+                               , "DOM_SYNTAX_ERR"+                               , "DOM_VALIDATION_ERR"+                               , "DOM_WRONG_DOCUMENT_ERR"+                               , "DOMSTRING_SIZE_ERR"+                               , "E_ALL"+                               , "E_COMPILE_ERROR"+                               , "E_COMPILE_WARNING"+                               , "E_CORE_ERROR"+                               , "E_CORE_WARNING"+                               , "E_DEPRECATED"+                               , "E_ERROR"+                               , "E_NOTICE"+                               , "E_PARSE"+                               , "E_RECOVERABLE_ERROR"+                               , "E_STRICT"+                               , "E_USER_DEPRECATED"+                               , "E_USER_ERROR"+                               , "E_USER_NOTICE"+                               , "E_USER_WARNING"+                               , "E_WARNING"+                               , "ENC7BIT"+                               , "ENC8BIT"+                               , "ENCBASE64"+                               , "ENCBINARY"+                               , "ENCOTHER"+                               , "ENCQUOTEDPRINTABLE"+                               , "ENT_COMPAT"+                               , "ENT_NOQUOTES"+                               , "ENT_QUOTES"+                               , "ERA"+                               , "ERA_D_FMT"+                               , "ERA_D_T_FMT"+                               , "ERA_T_FMT"+                               , "EXIF_USE_MBSTRING"+                               , "EXTR_IF_EXISTS"+                               , "EXTR_OVERWRITE"+                               , "EXTR_PREFIX_ALL"+                               , "EXTR_PREFIX_IF_EXISTS"+                               , "EXTR_PREFIX_INVALID"+                               , "EXTR_PREFIX_SAME"+                               , "EXTR_REFS"+                               , "EXTR_SKIP"+                               , "F_DUPFD"+                               , "F_GETFD"+                               , "F_GETFL"+                               , "F_GETLK"+                               , "F_GETOWN"+                               , "F_RDLCK"+                               , "F_SETFL"+                               , "F_SETLK"+                               , "F_SETLKW"+                               , "F_SETOWN"+                               , "F_UNLCK"+                               , "F_WRLCK"+                               , "false"+                               , "FAMAcknowledge"+                               , "FAMChanged"+                               , "FAMCreated"+                               , "FAMDeleted"+                               , "FAMEndExist"+                               , "FAMExists"+                               , "FAMMoved"+                               , "FAMStartExecuting"+                               , "FAMStopExecuting"+                               , "FILE_APPEND"+                               , "FILE_IGNORE_NEW_LINES"+                               , "FILE_NO_DEFAULT_CONTEXT"+                               , "FILE_SKIP_EMPTY_LINES"+                               , "FILE_USE_INCLUDE_PATH"+                               , "FNM_CASEFOLD"+                               , "FNM_NOESCAPE"+                               , "FNM_PATHNAME"+                               , "FNM_PERIOD"+                               , "FORCE_DEFLATE"+                               , "FORCE_GZIP"+                               , "FT_INTERNAL"+                               , "FT_NOT"+                               , "FT_PEEK"+                               , "FT_PREFETCHTEXT"+                               , "FT_UID"+                               , "FTP_ASCII"+                               , "FTP_AUTORESUME"+                               , "FTP_AUTOSEEK"+                               , "FTP_BINARY"+                               , "FTP_FAILED"+                               , "FTP_FINISHED"+                               , "FTP_IMAGE"+                               , "FTP_MOREDATA"+                               , "FTP_TEXT"+                               , "FTP_TIMEOUT_SEC"+                               , "GD_BUNDLED"+                               , "GLOB_BRACE"+                               , "GLOB_MARK"+                               , "GLOB_NOCHECK"+                               , "GLOB_NOESCAPE"+                               , "GLOB_NOSORT"+                               , "GLOB_ONLYDIR"+                               , "GMP_ROUND_MINUSINF"+                               , "GMP_ROUND_PLUSINF"+                               , "GMP_ROUND_ZERO"+                               , "HASH_HMAC"+                               , "HTML_ENTITIES"+                               , "HTML_SPECIALCHARS"+                               , "ICONV_IMPL"+                               , "ICONV_MIME_DECODE_CONTINUE_ON_ERROR"+                               , "ICONV_MIME_DECODE_STRICT"+                               , "ICONV_VERSION"+                               , "IMAGETYPE_BMP"+                               , "IMAGETYPE_GIF"+                               , "IMAGETYPE_IFF"+                               , "IMAGETYPE_JB2"+                               , "IMAGETYPE_JP2"+                               , "IMAGETYPE_JPC"+                               , "IMAGETYPE_JPEG"+                               , "IMAGETYPE_JPEG2000"+                               , "IMAGETYPE_JPX"+                               , "IMAGETYPE_PNG"+                               , "IMAGETYPE_PSD"+                               , "IMAGETYPE_SWF"+                               , "IMAGETYPE_TIFF_II"+                               , "IMAGETYPE_TIFF_MM"+                               , "IMAGETYPE_WBMP"+                               , "IMAGETYPE_XBM"+                               , "IMAP_CLOSETIMEOUT"+                               , "IMAP_OPENTIMEOUT"+                               , "IMAP_READTIMEOUT"+                               , "IMAP_WRITETIMEOUT"+                               , "IMG_ARC_CHORD"+                               , "IMG_ARC_EDGED"+                               , "IMG_ARC_NOFILL"+                               , "IMG_ARC_PIE"+                               , "IMG_ARC_ROUNDED"+                               , "IMG_COLOR_BRUSHED"+                               , "IMG_COLOR_STYLED"+                               , "IMG_COLOR_STYLEDBRUSHED"+                               , "IMG_COLOR_TILED"+                               , "IMG_COLOR_TRANSPARENT"+                               , "IMG_EFFECT_ALPHABLEND"+                               , "IMG_EFFECT_NORMAL"+                               , "IMG_EFFECT_OVERLAY"+                               , "IMG_EFFECT_REPLACE"+                               , "IMG_FILTER_BRIGHTNESS"+                               , "IMG_FILTER_COLORIZE"+                               , "IMG_FILTER_CONTRAST"+                               , "IMG_FILTER_EDGEDETECT"+                               , "IMG_FILTER_EMBOSS"+                               , "IMG_FILTER_GAUSSIAN_BLUR"+                               , "IMG_FILTER_GRAYSCALE"+                               , "IMG_FILTER_MEAN_REMOVAL"+                               , "IMG_FILTER_NEGATE"+                               , "IMG_FILTER_SELECTIVE_BLUR"+                               , "IMG_FILTER_SMOOTH"+                               , "IMG_GD2_COMPRESSED"+                               , "IMG_GD2_RAW"+                               , "IMG_GIF"+                               , "IMG_JPEG"+                               , "IMG_JPG"+                               , "IMG_PNG"+                               , "IMG_WBMP"+                               , "IMG_XPM"+                               , "INF"+                               , "INFO_ALL"+                               , "INFO_CONFIGURATION"+                               , "INFO_CREDITS"+                               , "INFO_ENVIRONMENT"+                               , "INFO_GENERAL"+                               , "INFO_LICENSE"+                               , "INFO_MODULES"+                               , "INFO_VARIABLES"+                               , "INI_ALL"+                               , "INI_PERDIR"+                               , "INI_SYSTEM"+                               , "INI_USER"+                               , "LATT_HASCHILDREN"+                               , "LATT_HASNOCHILDREN"+                               , "LATT_MARKED"+                               , "LATT_NOINFERIORS"+                               , "LATT_NOSELECT"+                               , "LATT_REFERRAL"+                               , "LATT_UNMARKED"+                               , "LC_ALL"+                               , "LC_COLLATE"+                               , "LC_CTYPE"+                               , "LC_MESSAGES"+                               , "LC_MONETARY"+                               , "LC_NUMERIC"+                               , "LC_TIME"+                               , "LDAP_DEREF_ALWAYS"+                               , "LDAP_DEREF_FINDING"+                               , "LDAP_DEREF_NEVER"+                               , "LDAP_DEREF_SEARCHING"+                               , "LDAP_OPT_CLIENT_CONTROLS"+                               , "LDAP_OPT_DEBUG_LEVEL"+                               , "LDAP_OPT_DEREF"+                               , "LDAP_OPT_ERROR_NUMBER"+                               , "LDAP_OPT_ERROR_STRING"+                               , "LDAP_OPT_HOST_NAME"+                               , "LDAP_OPT_MATCHED_DN"+                               , "LDAP_OPT_PROTOCOL_VERSION"+                               , "LDAP_OPT_REFERRALS"+                               , "LDAP_OPT_RESTART"+                               , "LDAP_OPT_SERVER_CONTROLS"+                               , "LDAP_OPT_SIZELIMIT"+                               , "LDAP_OPT_TIMELIMIT"+                               , "LIBXML_COMPACT"+                               , "LIBXML_DOTTED_VERSION"+                               , "LIBXML_DTDATTR"+                               , "LIBXML_DTDLOAD"+                               , "LIBXML_DTDVALID"+                               , "LIBXML_ERR_ERROR"+                               , "LIBXML_ERR_FATAL"+                               , "LIBXML_ERR_NONE"+                               , "LIBXML_ERR_WARNING"+                               , "LIBXML_NOBLANKS"+                               , "LIBXML_NOCDATA"+                               , "LIBXML_NOEMPTYTAG"+                               , "LIBXML_NOENT"+                               , "LIBXML_NOERROR"+                               , "LIBXML_NONET"+                               , "LIBXML_NOWARNING"+                               , "LIBXML_NOXMLDECL"+                               , "LIBXML_NSCLEAN"+                               , "LIBXML_VERSION"+                               , "LIBXML_XINCLUDE"+                               , "LOCK_EX"+                               , "LOCK_NB"+                               , "LOCK_SH"+                               , "LOCK_UN"+                               , "LOG_ALERT"+                               , "LOG_AUTH"+                               , "LOG_AUTHPRIV"+                               , "LOG_CONS"+                               , "LOG_CRIT"+                               , "LOG_CRON"+                               , "LOG_DAEMON"+                               , "LOG_DEBUG"+                               , "LOG_EMERG"+                               , "LOG_ERR"+                               , "LOG_INFO"+                               , "LOG_KERN"+                               , "LOG_LOCAL0"+                               , "LOG_LOCAL1"+                               , "LOG_LOCAL2"+                               , "LOG_LOCAL3"+                               , "LOG_LOCAL4"+                               , "LOG_LOCAL5"+                               , "LOG_LOCAL6"+                               , "LOG_LOCAL7"+                               , "LOG_LPR"+                               , "LOG_MAIL"+                               , "LOG_NDELAY"+                               , "LOG_NEWS"+                               , "LOG_NOTICE"+                               , "LOG_NOWAIT"+                               , "LOG_ODELAY"+                               , "LOG_PERROR"+                               , "LOG_PID"+                               , "LOG_SYSLOG"+                               , "LOG_USER"+                               , "LOG_UUCP"+                               , "LOG_WARNING"+                               , "M_1_PI"+                               , "M_2_PI"+                               , "M_2_SQRTPI"+                               , "M_ABSTRACT"+                               , "M_E"+                               , "M_FINAL"+                               , "M_LN10"+                               , "M_LN2"+                               , "M_LOG10E"+                               , "M_LOG2E"+                               , "M_PI"+                               , "M_PI_2"+                               , "M_PI_4"+                               , "M_PRIVATE"+                               , "M_PROTECTED"+                               , "M_PUBLIC"+                               , "M_SQRT1_2"+                               , "M_SQRT2"+                               , "M_STATIC"+                               , "MB_CASE_LOWER"+                               , "MB_CASE_TITLE"+                               , "MB_CASE_UPPER"+                               , "MB_OVERLOAD_MAIL"+                               , "MB_OVERLOAD_REGEX"+                               , "MB_OVERLOAD_STRING"+                               , "MCRYPT_3DES"+                               , "MCRYPT_ARCFOUR"+                               , "MCRYPT_ARCFOUR_IV"+                               , "MCRYPT_BLOWFISH"+                               , "MCRYPT_BLOWFISH_COMPAT"+                               , "MCRYPT_CAST_128"+                               , "MCRYPT_CAST_256"+                               , "MCRYPT_CRYPT"+                               , "MCRYPT_DECRYPT"+                               , "MCRYPT_DES"+                               , "MCRYPT_DEV_RANDOM"+                               , "MCRYPT_DEV_URANDOM"+                               , "MCRYPT_ENCRYPT"+                               , "MCRYPT_ENIGNA"+                               , "MCRYPT_GOST"+                               , "MCRYPT_IDEA"+                               , "MCRYPT_LOKI97"+                               , "MCRYPT_MARS"+                               , "MCRYPT_MODE_CBC"+                               , "MCRYPT_MODE_CFB"+                               , "MCRYPT_MODE_ECB"+                               , "MCRYPT_MODE_NOFB"+                               , "MCRYPT_MODE_OFB"+                               , "MCRYPT_MODE_STREAM"+                               , "MCRYPT_PANAMA"+                               , "MCRYPT_RAND"+                               , "MCRYPT_RC2"+                               , "MCRYPT_RC6"+                               , "MCRYPT_RIJNDAEL_128"+                               , "MCRYPT_RIJNDAEL_192"+                               , "MCRYPT_RIJNDAEL_256"+                               , "MCRYPT_SAFER128"+                               , "MCRYPT_SAFER64"+                               , "MCRYPT_SAFERPLUS"+                               , "MCRYPT_SERPENT"+                               , "MCRYPT_SKIPJACK"+                               , "MCRYPT_THREEWAY"+                               , "MCRYPT_TRIPLEDES"+                               , "MCRYPT_TWOFISH"+                               , "MCRYPT_WAKE"+                               , "MCRYPT_XTEA"+                               , "MHASH_ADLER32"+                               , "MHASH_CRC32"+                               , "MHASH_CRC32B"+                               , "MHASH_GOST"+                               , "MHASH_HAVAL128"+                               , "MHASH_HAVAL160"+                               , "MHASH_HAVAL192"+                               , "MHASH_HAVAL224"+                               , "MHASH_HAVAL256"+                               , "MHASH_MD2"+                               , "MHASH_MD4"+                               , "MHASH_MD5"+                               , "MHASH_RIPEMD128"+                               , "MHASH_RIPEMD160"+                               , "MHASH_RIPEMD256"+                               , "MHASH_RIPEMD320"+                               , "MHASH_SHA1"+                               , "MHASH_SHA224"+                               , "MHASH_SHA256"+                               , "MHASH_SHA384"+                               , "MHASH_SHA512"+                               , "MHASH_SNEFRU128"+                               , "MHASH_SNEFRU256"+                               , "MHASH_TIGER"+                               , "MHASH_TIGER128"+                               , "MHASH_TIGER160"+                               , "MHASH_WHIRLPOOL"+                               , "MON_1"+                               , "MON_10"+                               , "MON_11"+                               , "MON_12"+                               , "MON_2"+                               , "MON_3"+                               , "MON_4"+                               , "MON_5"+                               , "MON_6"+                               , "MON_7"+                               , "MON_8"+                               , "MON_9"+                               , "MSG_DONTROUTE"+                               , "MSG_EXCEPT"+                               , "MSG_IPC_NOWAIT"+                               , "MSG_NOERROR"+                               , "MSG_OOB"+                               , "MSG_PEEK"+                               , "MSG_WAITALL"+                               , "MYSQL_ASSOC"+                               , "MYSQL_BOTH"+                               , "MYSQL_CLIENT_COMPRESS"+                               , "MYSQL_CLIENT_IGNORE_SPACE"+                               , "MYSQL_CLIENT_INTERACTIVE"+                               , "MYSQL_CLIENT_SSL"+                               , "MYSQL_NUM"+                               , "MYSQLI_ASSOC"+                               , "MYSQLI_AUTO_INCREMENT_FLAG"+                               , "MYSQLI_BLOB_FLAG"+                               , "MYSQLI_BOTH"+                               , "MYSQLI_CLIENT_COMPRESS"+                               , "MYSQLI_CLIENT_FOUND_ROWS"+                               , "MYSQLI_CLIENT_IGNORE_SPACE"+                               , "MYSQLI_CLIENT_INTERACTIVE"+                               , "MYSQLI_CLIENT_NO_SCHEMA"+                               , "MYSQLI_CLIENT_SSL"+                               , "MYSQLI_GROUP_FLAG"+                               , "MYSQLI_INIT_COMMAND"+                               , "MYSQLI_MULTIPLE_KEY_FLAG"+                               , "MYSQLI_NO_DATA"+                               , "MYSQLI_NOT_NULL_FLAG"+                               , "MYSQLI_NUM"+                               , "MYSQLI_NUM_FLAG"+                               , "MYSQLI_OPT_CONNECT_TIMEOUT"+                               , "MYSQLI_OPT_LOCAL_INFILE"+                               , "MYSQLI_PART_KEY_FLAG"+                               , "MYSQLI_PRI_KEY_FLAG"+                               , "MYSQLI_READ_DEFAULT_FILE"+                               , "MYSQLI_READ_DEFAULT_GROUP"+                               , "MYSQLI_REPORT_ALL"+                               , "MYSQLI_REPORT_ERROR"+                               , "MYSQLI_REPORT_INDEX"+                               , "MYSQLI_REPORT_OFF"+                               , "MYSQLI_REPORT_STRICT"+                               , "MYSQLI_RPL_ADMIN"+                               , "MYSQLI_RPL_MASTER"+                               , "MYSQLI_RPL_SLAVE"+                               , "MYSQLI_SET_FLAG"+                               , "MYSQLI_STMT_ATTR_UPDATE_MAX_LENGTH"+                               , "MYSQLI_STORE_RESULT"+                               , "MYSQLI_TIMESTAMP_FLAG"+                               , "MYSQLI_TYPE_BLOB"+                               , "MYSQLI_TYPE_CHAR"+                               , "MYSQLI_TYPE_DATE"+                               , "MYSQLI_TYPE_DATETIME"+                               , "MYSQLI_TYPE_DECIMAL"+                               , "MYSQLI_TYPE_DOUBLE"+                               , "MYSQLI_TYPE_ENUM"+                               , "MYSQLI_TYPE_FLOAT"+                               , "MYSQLI_TYPE_GEOMETRY"+                               , "MYSQLI_TYPE_INT24"+                               , "MYSQLI_TYPE_INTERVAL"+                               , "MYSQLI_TYPE_LONG"+                               , "MYSQLI_TYPE_LONG_BLOB"+                               , "MYSQLI_TYPE_LONGLONG"+                               , "MYSQLI_TYPE_MEDIUM_BLOB"+                               , "MYSQLI_TYPE_NEWDATE"+                               , "MYSQLI_TYPE_NULL"+                               , "MYSQLI_TYPE_SET"+                               , "MYSQLI_TYPE_SHORT"+                               , "MYSQLI_TYPE_STRING"+                               , "MYSQLI_TYPE_TIME"+                               , "MYSQLI_TYPE_TIMESTAMP"+                               , "MYSQLI_TYPE_TINY"+                               , "MYSQLI_TYPE_TINY_BLOB"+                               , "MYSQLI_TYPE_VAR_STRING"+                               , "MYSQLI_TYPE_YEAR"+                               , "MYSQLI_UNIQUE_KEY_FLAG"+                               , "MYSQLI_UNSIGNED_FLAG"+                               , "MYSQLI_USE_RESULT"+                               , "MYSQLI_ZEROFILL_FLAG"+                               , "NAN"+                               , "NCURSES_A_ALTCHARSET"+                               , "NCURSES_A_BLINK"+                               , "NCURSES_A_BOLD"+                               , "NCURSES_A_CHARTEXT"+                               , "NCURSES_A_DIM"+                               , "NCURSES_A_INVIS"+                               , "NCURSES_A_NORMAL"+                               , "NCURSES_A_PROTECT"+                               , "NCURSES_A_REVERSE"+                               , "NCURSES_A_STANDOUT"+                               , "NCURSES_A_UNDERLINE"+                               , "NCURSES_ALL_MOUSE_EVENTS"+                               , "NCURSES_BUTTON1_CLICKED"+                               , "NCURSES_BUTTON1_DOUBLE_CLICKED"+                               , "NCURSES_BUTTON1_PRESSED"+                               , "NCURSES_BUTTON1_RELEASED"+                               , "NCURSES_BUTTON1_TRIPLE_CLICKED"+                               , "NCURSES_BUTTON2_CLICKED"+                               , "NCURSES_BUTTON2_DOUBLE_CLICKED"+                               , "NCURSES_BUTTON2_PRESSED"+                               , "NCURSES_BUTTON2_RELEASED"+                               , "NCURSES_BUTTON2_TRIPLE_CLICKED"+                               , "NCURSES_BUTTON3_CLICKED"+                               , "NCURSES_BUTTON3_DOUBLE_CLICKED"+                               , "NCURSES_BUTTON3_PRESSED"+                               , "NCURSES_BUTTON3_RELEASED"+                               , "NCURSES_BUTTON3_TRIPLE_CLICKED"+                               , "NCURSES_BUTTON4_CLICKED"+                               , "NCURSES_BUTTON4_DOUBLE_CLICKED"+                               , "NCURSES_BUTTON4_PRESSED"+                               , "NCURSES_BUTTON4_RELEASED"+                               , "NCURSES_BUTTON4_TRIPLE_CLICKED"+                               , "NCURSES_BUTTON_ALT"+                               , "NCURSES_BUTTON_CTRL"+                               , "NCURSES_BUTTON_SHIFT"+                               , "NCURSES_COLOR_BLACK"+                               , "NCURSES_COLOR_BLUE"+                               , "NCURSES_COLOR_CYAN"+                               , "NCURSES_COLOR_GREEN"+                               , "NCURSES_COLOR_MAGENTA"+                               , "NCURSES_COLOR_RED"+                               , "NCURSES_COLOR_WHITE"+                               , "NCURSES_COLOR_YELLOW"+                               , "NCURSES_KEY_A1"+                               , "NCURSES_KEY_A3"+                               , "NCURSES_KEY_B2"+                               , "NCURSES_KEY_BACKSPACE"+                               , "NCURSES_KEY_BEG"+                               , "NCURSES_KEY_BTAB"+                               , "NCURSES_KEY_C1"+                               , "NCURSES_KEY_C3"+                               , "NCURSES_KEY_CANCEL"+                               , "NCURSES_KEY_CATAB"+                               , "NCURSES_KEY_CLEAR"+                               , "NCURSES_KEY_CLOSE"+                               , "NCURSES_KEY_COMMAND"+                               , "NCURSES_KEY_COPY"+                               , "NCURSES_KEY_CREATE"+                               , "NCURSES_KEY_CTAB"+                               , "NCURSES_KEY_DC"+                               , "NCURSES_KEY_DL"+                               , "NCURSES_KEY_DOWN"+                               , "NCURSES_KEY_EIC"+                               , "NCURSES_KEY_END"+                               , "NCURSES_KEY_ENTER"+                               , "NCURSES_KEY_EOL"+                               , "NCURSES_KEY_EOS"+                               , "NCURSES_KEY_EXIT"+                               , "NCURSES_KEY_F0"+                               , "NCURSES_KEY_F1"+                               , "NCURSES_KEY_F10"+                               , "NCURSES_KEY_F11"+                               , "NCURSES_KEY_F12"+                               , "NCURSES_KEY_F2"+                               , "NCURSES_KEY_F3"+                               , "NCURSES_KEY_F4"+                               , "NCURSES_KEY_F5"+                               , "NCURSES_KEY_F6"+                               , "NCURSES_KEY_F7"+                               , "NCURSES_KEY_F8"+                               , "NCURSES_KEY_F9"+                               , "NCURSES_KEY_FIND"+                               , "NCURSES_KEY_HELP"+                               , "NCURSES_KEY_IC"+                               , "NCURSES_KEY_IL"+                               , "NCURSES_KEY_LEFT"+                               , "NCURSES_KEY_LL"+                               , "NCURSES_KEY_MARK"+                               , "NCURSES_KEY_MESSAGE"+                               , "NCURSES_KEY_MOUSE"+                               , "NCURSES_KEY_MOVE"+                               , "NCURSES_KEY_NEXT"+                               , "NCURSES_KEY_NPAGE"+                               , "NCURSES_KEY_OPEN"+                               , "NCURSES_KEY_OPTIONS"+                               , "NCURSES_KEY_PPAGE"+                               , "NCURSES_KEY_PREVIOUS"+                               , "NCURSES_KEY_PRINT"+                               , "NCURSES_KEY_REDO"+                               , "NCURSES_KEY_REFERENCE"+                               , "NCURSES_KEY_REFRESH"+                               , "NCURSES_KEY_REPLACE"+                               , "NCURSES_KEY_RESET"+                               , "NCURSES_KEY_RESIZE"+                               , "NCURSES_KEY_RESTART"+                               , "NCURSES_KEY_RESUME"+                               , "NCURSES_KEY_RIGHT"+                               , "NCURSES_KEY_SAVE"+                               , "NCURSES_KEY_SBEG"+                               , "NCURSES_KEY_SCANCEL"+                               , "NCURSES_KEY_SCOMMAND"+                               , "NCURSES_KEY_SCOPY"+                               , "NCURSES_KEY_SCREATE"+                               , "NCURSES_KEY_SDC"+                               , "NCURSES_KEY_SDL"+                               , "NCURSES_KEY_SELECT"+                               , "NCURSES_KEY_SEND"+                               , "NCURSES_KEY_SEOL"+                               , "NCURSES_KEY_SEXIT"+                               , "NCURSES_KEY_SF"+                               , "NCURSES_KEY_SFIND"+                               , "NCURSES_KEY_SHELP"+                               , "NCURSES_KEY_SHOME"+                               , "NCURSES_KEY_SIC"+                               , "NCURSES_KEY_SLEFT"+                               , "NCURSES_KEY_SMESSAGE"+                               , "NCURSES_KEY_SMOVE"+                               , "NCURSES_KEY_SNEXT"+                               , "NCURSES_KEY_SOPTIONS"+                               , "NCURSES_KEY_SPREVIOUS"+                               , "NCURSES_KEY_SPRINT"+                               , "NCURSES_KEY_SR"+                               , "NCURSES_KEY_SREDO"+                               , "NCURSES_KEY_SREPLACE"+                               , "NCURSES_KEY_SRESET"+                               , "NCURSES_KEY_SRIGHT"+                               , "NCURSES_KEY_SRSUME"+                               , "NCURSES_KEY_SSAVE"+                               , "NCURSES_KEY_SSUSPEND"+                               , "NCURSES_KEY_STAB"+                               , "NCURSES_KEY_SUNDO"+                               , "NCURSES_KEY_SUSPEND"+                               , "NCURSES_KEY_UNDO"+                               , "NCURSES_KEY_UP"+                               , "NCURSES_REPORT_MOUSE_POSITION"+                               , "NIL"+                               , "NOEXPR"+                               , "null"+                               , "O_APPEND"+                               , "O_ASYNC"+                               , "O_CREAT"+                               , "O_EXCL"+                               , "O_NDELAY"+                               , "O_NOCTTY"+                               , "O_NONBLOCK"+                               , "O_RDONLY"+                               , "O_RDWR"+                               , "O_SYNC"+                               , "O_TRUNC"+                               , "O_WRONLY"+                               , "OCI_ASSOC"+                               , "OCI_B_BFILE"+                               , "OCI_B_BIN"+                               , "OCI_B_BLOB"+                               , "OCI_B_CFILEE"+                               , "OCI_B_CLOB"+                               , "OCI_B_CURSOR"+                               , "OCI_B_INT"+                               , "OCI_B_NTY"+                               , "OCI_B_NUM"+                               , "OCI_B_ROWID"+                               , "OCI_BOTH"+                               , "OCI_COMMIT_ON_SUCCESS"+                               , "OCI_CRED_EXT"+                               , "OCI_DEFAULT"+                               , "OCI_DESCRIBE_ONLY"+                               , "OCI_DTYPE_FILE"+                               , "OCI_DTYPE_LOB"+                               , "OCI_DTYPE_ROWID"+                               , "OCI_FETCHSTATEMENT_BY_COLUMN"+                               , "OCI_FETCHSTATEMENT_BY_ROW"+                               , "OCI_LOB_BUFFER_FREE"+                               , "OCI_NO_AUTO_COMMIT"+                               , "OCI_NUM"+                               , "OCI_RETURN_LOBS"+                               , "OCI_RETURN_NULLS"+                               , "OCI_SEEK_CUR"+                               , "OCI_SEEK_END"+                               , "OCI_SEEK_SET"+                               , "OCI_SYSDBA"+                               , "OCI_SYSOPER"+                               , "OCI_TEMP_BLOB"+                               , "OCI_TEMP_CLOB"+                               , "ODBC_BINMODE_CONVERT"+                               , "ODBC_BINMODE_PASSTHRU"+                               , "ODBC_BINMODE_RETURN"+                               , "ODBC_TYPE"+                               , "OP_ANONYMOUS"+                               , "OP_DEBUG"+                               , "OP_EXPUNGE"+                               , "OP_HALFOPEN"+                               , "OP_PROTOTYPE"+                               , "OP_READONLY"+                               , "OP_SECURE"+                               , "OP_SHORTCACHE"+                               , "OP_SILENT"+                               , "OPENSSL_ALGO_MD2"+                               , "OPENSSL_ALGO_MD4"+                               , "OPENSSL_ALGO_MD5"+                               , "OPENSSL_ALGO_SHA1"+                               , "OPENSSL_CIPHER_3DES"+                               , "OPENSSL_CIPHER_DES"+                               , "OPENSSL_CIPHER_RC2_128"+                               , "OPENSSL_CIPHER_RC2_40"+                               , "OPENSSL_CIPHER_RC2_64"+                               , "OPENSSL_KEYTYPE_DH"+                               , "OPENSSL_KEYTYPE_DSA"+                               , "OPENSSL_KEYTYPE_RSA"+                               , "OPENSSL_NO_PADDING"+                               , "OPENSSL_PKCS1_OAEP_PADDING"+                               , "OPENSSL_PKCS1_PADDING"+                               , "OPENSSL_SSLV23_PADDING"+                               , "P_PRIVATE"+                               , "P_PROTECTED"+                               , "P_PUBLIC"+                               , "P_STATIC"+                               , "PATH_SEPARATOR"+                               , "PATHINFO_BASENAME"+                               , "PATHINFO_DIRNAME"+                               , "PATHINFO_EXTENSION"+                               , "PATHINFO_FILENAME"+                               , "PEAR_EXTENSION_DIR"+                               , "PEAR_INSTALL_DIR"+                               , "PGSQL_ASSOC"+                               , "PGSQL_BAD_RESPONSE"+                               , "PGSQL_BOTH"+                               , "PGSQL_COMMAND_OK"+                               , "PGSQL_CONNECT_FORCE_NEW"+                               , "PGSQL_CONNECTION_BAD"+                               , "PGSQL_CONNECTION_OK"+                               , "PGSQL_CONV_FORCE_NULL"+                               , "PGSQL_CONV_IGNORE_DEFAULT"+                               , "PGSQL_CONV_IGNORE_NOT_NULL"+                               , "PGSQL_COPY_IN"+                               , "PGSQL_COPY_OUT"+                               , "PGSQL_DML_ASYNC"+                               , "PGSQL_DML_EXEC"+                               , "PGSQL_DML_NO_CONV"+                               , "PGSQL_DML_STRING"+                               , "PGSQL_EMPTY_QUERY"+                               , "PGSQL_FATAL_ERROR"+                               , "PGSQL_NONFATAL_ERROR"+                               , "PGSQL_NUM"+                               , "PGSQL_SEEK_CUR"+                               , "PGSQL_SEEK_END"+                               , "PGSQL_SEEK_SET"+                               , "PGSQL_STATUS_LONG"+                               , "PGSQL_STATUS_STRING"+                               , "PGSQL_TUPLES_OK"+                               , "PHP_BINARY_READ"+                               , "PHP_BINDIR"+                               , "PHP_CONFIG_FILE_PATH"+                               , "PHP_CONFIG_FILE_SCAN_DIR"+                               , "PHP_DATADIR"+                               , "PHP_EOL"+                               , "PHP_EXTENSION_DIR"+                               , "PHP_LIBDIR"+                               , "PHP_LOCALSTATEDIR"+                               , "PHP_NORMAL_READ"+                               , "PHP_OS"+                               , "PHP_OUTPUT_HANDLER_CONT"+                               , "PHP_OUTPUT_HANDLER_END"+                               , "PHP_OUTPUT_HANDLER_START"+                               , "PHP_PREFIX"+                               , "PHP_SAPI"+                               , "PHP_SHLIB_SUFFIX"+                               , "PHP_SYSCONFDIR"+                               , "PHP_URL_FRAGMENT"+                               , "PHP_URL_HOST"+                               , "PHP_URL_PASS"+                               , "PHP_URL_PATH"+                               , "PHP_URL_PORT"+                               , "PHP_URL_QUERY"+                               , "PHP_URL_SCHEME"+                               , "PHP_URL_USER"+                               , "PHP_VERSION"+                               , "PKCS7_BINARY"+                               , "PKCS7_DETACHED"+                               , "PKCS7_NOATTR"+                               , "PKCS7_NOCERTS"+                               , "PKCS7_NOCHAIN"+                               , "PKCS7_NOINTERN"+                               , "PKCS7_NOSIGS"+                               , "PKCS7_NOVERIFY"+                               , "PKCS7_TEXT"+                               , "PM_STR"+                               , "PREG_GREP_INVERT"+                               , "PREG_OFFSET_CAPTURE"+                               , "PREG_PATTERN_ORDER"+                               , "PREG_SET_ORDER"+                               , "PREG_SPLIT_DELIM_CAPTURE"+                               , "PREG_SPLIT_NO_EMPTY"+                               , "PREG_SPLIT_OFFSET_CAPTURE"+                               , "PRIO_PGRP"+                               , "PRIO_PROCESS"+                               , "PRIO_USER"+                               , "PSFS_ERR_FATAL"+                               , "PSFS_FEED_ME"+                               , "PSFS_FLAG_FLUSH_CLOSE"+                               , "PSFS_FLAG_FLUSH_INC"+                               , "PSFS_FLAG_NORMAL"+                               , "PSFS_PASS_ON"+                               , "RADIXCHAR"+                               , "RIT_CHILD_FIRST"+                               , "RIT_LEAVES_ONLY"+                               , "RIT_SELF_FIRST"+                               , "S_IRGRP"+                               , "S_IROTH"+                               , "S_IRUSR"+                               , "S_IRWXG"+                               , "S_IRWXO"+                               , "S_IRWXU"+                               , "S_IWGRP"+                               , "S_IWOTH"+                               , "S_IWUSR"+                               , "S_IXGRP"+                               , "S_IXOTH"+                               , "S_IXUSR"+                               , "SA_ALL"+                               , "SA_MESSAGES"+                               , "SA_RECENT"+                               , "SA_UIDNEXT"+                               , "SA_UIDVALIDITY"+                               , "SA_UNSEEN"+                               , "SE_FREE"+                               , "SE_NOPREFETCH"+                               , "SE_UID"+                               , "SEEK_CUR"+                               , "SEEK_END"+                               , "SEEK_SET"+                               , "SIG_DFL"+                               , "SIG_ERR"+                               , "SIG_IGN"+                               , "SIGABRT"+                               , "SIGALRM"+                               , "SIGBABY"+                               , "SIGBUS"+                               , "SIGCHLD"+                               , "SIGCLD"+                               , "SIGCONT"+                               , "SIGFPE"+                               , "SIGHUP"+                               , "SIGILL"+                               , "SIGINT"+                               , "SIGIO"+                               , "SIGIOT"+                               , "SIGKILL"+                               , "SIGPIPE"+                               , "SIGPOLL"+                               , "SIGPROF"+                               , "SIGPWR"+                               , "SIGQUIT"+                               , "SIGSEGV"+                               , "SIGSTKFLT"+                               , "SIGSTOP"+                               , "SIGSYS"+                               , "SIGTERM"+                               , "SIGTRAP"+                               , "SIGTSTP"+                               , "SIGTTIN"+                               , "SIGTTOU"+                               , "SIGURG"+                               , "SIGUSR1"+                               , "SIGUSR2"+                               , "SIGVTALRM"+                               , "SIGWINCH"+                               , "SIGXCPU"+                               , "SIGXFSZ"+                               , "SNMP_BIT_STR"+                               , "SNMP_COUNTER"+                               , "SNMP_COUNTER64"+                               , "SNMP_INTEGER"+                               , "SNMP_IPADDRESS"+                               , "SNMP_NULL"+                               , "SNMP_OBJECT_ID"+                               , "SNMP_OCTET_STR"+                               , "SNMP_OPAQUE"+                               , "SNMP_TIMETICKS"+                               , "SNMP_UINTEGER"+                               , "SNMP_UNSIGNED"+                               , "SNMP_VALUE_LIBRARY"+                               , "SNMP_VALUE_OBJECT"+                               , "SNMP_VALUE_PLAIN"+                               , "SO_BROADCAST"+                               , "SO_DEBUG"+                               , "SO_DONTROUTE"+                               , "SO_ERROR"+                               , "SO_FREE"+                               , "SO_KEEPALIVE"+                               , "SO_LINGER"+                               , "SO_NOSERVER"+                               , "SO_OOBINLINE"+                               , "SO_RCVBUF"+                               , "SO_RCVLOWAT"+                               , "SO_RCVTIMEO"+                               , "SO_REUSEADDR"+                               , "SO_SNDBUF"+                               , "SO_SNDLOWAT"+                               , "SO_SNDTIMEO"+                               , "SO_TYPE"+                               , "SOAP_1_1"+                               , "SOAP_1_2"+                               , "SOAP_ACTOR_NEXT"+                               , "SOAP_ACTOR_NONE"+                               , "SOAP_ACTOR_UNLIMATERECEIVER"+                               , "SOAP_COMPRESSION_ACCEPT"+                               , "SOAP_COMPRESSION_DEFLATE"+                               , "SOAP_COMPRESSION_GZIP"+                               , "SOAP_DOCUMENT"+                               , "SOAP_ENC_ARRAY"+                               , "SOAP_ENC_OBJECT"+                               , "SOAP_ENCODED"+                               , "SOAP_FUNCTIONS_ALL"+                               , "SOAP_LITERAL"+                               , "SOAP_PERSISTENCE_REQUEST"+                               , "SOAP_PERSISTENCE_SESSION"+                               , "SOAP_RPC"+                               , "SOCK_DGRAM"+                               , "SOCK_RAW"+                               , "SOCK_RDM"+                               , "SOCK_SEQPACKET"+                               , "SOCK_STREAM"+                               , "SOCKET_E2BIG"+                               , "SOCKET_EACCES"+                               , "SOCKET_EADDRINUSE"+                               , "SOCKET_EADDRNOTAVAIL"+                               , "SOCKET_EADV"+                               , "SOCKET_EAFNOSUPPORT"+                               , "SOCKET_EAGAIN"+                               , "SOCKET_EALREADY"+                               , "SOCKET_EBADE"+                               , "SOCKET_EBADF"+                               , "SOCKET_EBADFD"+                               , "SOCKET_EBADMSG"+                               , "SOCKET_EBADR"+                               , "SOCKET_EBADRQC"+                               , "SOCKET_EBADSLT"+                               , "SOCKET_EBUSY"+                               , "SOCKET_ECHRNG"+                               , "SOCKET_ECOMM"+                               , "SOCKET_ECONNABORTED"+                               , "SOCKET_ECONNREFUSED"+                               , "SOCKET_ECONNRESET"+                               , "SOCKET_EDESTADDRREQ"+                               , "SOCKET_EDQUOT"+                               , "SOCKET_EEXIST"+                               , "SOCKET_EFAULT"+                               , "SOCKET_EHOSTDOWN"+                               , "SOCKET_EHOSTUNREACH"+                               , "SOCKET_EIDRM"+                               , "SOCKET_EINPROGRESS"+                               , "SOCKET_EINTR"+                               , "SOCKET_EINVAL"+                               , "SOCKET_EIO"+                               , "SOCKET_EISCONN"+                               , "SOCKET_EISDIR"+                               , "SOCKET_EISNAM"+                               , "SOCKET_EL2HLT"+                               , "SOCKET_EL2NSYNC"+                               , "SOCKET_EL3HLT"+                               , "SOCKET_EL3RST"+                               , "SOCKET_ELNRNG"+                               , "SOCKET_ELOOP"+                               , "SOCKET_EMEDIUMTYPE"+                               , "SOCKET_EMFILE"+                               , "SOCKET_EMLINK"+                               , "SOCKET_EMSGSIZE"+                               , "SOCKET_EMULTIHOP"+                               , "SOCKET_ENAMETOOLONG"+                               , "SOCKET_ENETDOWN"+                               , "SOCKET_ENETRESET"+                               , "SOCKET_ENETUNREACH"+                               , "SOCKET_ENFILE"+                               , "SOCKET_ENOANO"+                               , "SOCKET_ENOBUFS"+                               , "SOCKET_ENOCSI"+                               , "SOCKET_ENODATA"+                               , "SOCKET_ENODEV"+                               , "SOCKET_ENOENT"+                               , "SOCKET_ENOLCK"+                               , "SOCKET_ENOLINK"+                               , "SOCKET_ENOMEDIUM"+                               , "SOCKET_ENOMEM"+                               , "SOCKET_ENOMSG"+                               , "SOCKET_ENONET"+                               , "SOCKET_ENOPROTOOPT"+                               , "SOCKET_ENOSPC"+                               , "SOCKET_ENOSR"+                               , "SOCKET_ENOSTR"+                               , "SOCKET_ENOSYS"+                               , "SOCKET_ENOTBLK"+                               , "SOCKET_ENOTCONN"+                               , "SOCKET_ENOTDIR"+                               , "SOCKET_ENOTEMPTY"+                               , "SOCKET_ENOTSOCK"+                               , "SOCKET_ENOTTY"+                               , "SOCKET_ENOTUNIQ"+                               , "SOCKET_ENXIO"+                               , "SOCKET_EOPNOTSUPP"+                               , "SOCKET_EPERM"+                               , "SOCKET_EPFNOSUPPORT"+                               , "SOCKET_EPIPE"+                               , "SOCKET_EPROTO"+                               , "SOCKET_EPROTONOSUPPORT"+                               , "SOCKET_EPROTOTYPE"+                               , "SOCKET_EREMCHG"+                               , "SOCKET_EREMOTE"+                               , "SOCKET_EREMOTEIO"+                               , "SOCKET_ERESTART"+                               , "SOCKET_EROFS"+                               , "SOCKET_ESHUTDOWN"+                               , "SOCKET_ESOCKTNOSUPPORT"+                               , "SOCKET_ESPIPE"+                               , "SOCKET_ESRMNT"+                               , "SOCKET_ESTRPIPE"+                               , "SOCKET_ETIME"+                               , "SOCKET_ETIMEDOUT"+                               , "SOCKET_ETOOMANYREFS"+                               , "SOCKET_EUNATCH"+                               , "SOCKET_EUSERS"+                               , "SOCKET_EWOULDBLOCK"+                               , "SOCKET_EXDEV"+                               , "SOCKET_EXFULL"+                               , "SOL_SOCKET"+                               , "SOL_TCP"+                               , "SOL_UDP"+                               , "SOMAXCONN"+                               , "SORT_ASC"+                               , "SORT_DESC"+                               , "SORT_FLAG_CASE"+                               , "SORT_LOCALE_STRING"+                               , "SORT_NATURAL"+                               , "SORT_NUMERIC"+                               , "SORT_REGULAR"+                               , "SORT_STRING"+                               , "SORTARRIVAL"+                               , "SORTCC"+                               , "SORTDATE"+                               , "SORTFROM"+                               , "SORTSIZE"+                               , "SORTSUBJECT"+                               , "SORTTO"+                               , "SQL_BIGINT"+                               , "SQL_BINARY"+                               , "SQL_BIT"+                               , "SQL_CHAR"+                               , "SQL_CONCUR_LOCK"+                               , "SQL_CONCUR_READ_ONLY"+                               , "SQL_CONCUR_ROWVER"+                               , "SQL_CONCUR_VALUES"+                               , "SQL_CONCURRENCY"+                               , "SQL_CUR_USE_DRIVER"+                               , "SQL_CUR_USE_IF_NEEDED"+                               , "SQL_CUR_USE_ODBC"+                               , "SQL_CURSOR_DYNAMIC"+                               , "SQL_CURSOR_FORWARD_ONLY"+                               , "SQL_CURSOR_KEYSET_DRIVEN"+                               , "SQL_CURSOR_STATIC"+                               , "SQL_CURSOR_TYPE"+                               , "SQL_DATE"+                               , "SQL_DECIMAL"+                               , "SQL_DOUBLE"+                               , "SQL_FETCH_FIRST"+                               , "SQL_FETCH_NEXT"+                               , "SQL_FLOAT"+                               , "SQL_INTEGER"+                               , "SQL_KEYSET_SIZE"+                               , "SQL_LONGVARBINARY"+                               , "SQL_LONGVARCHAR"+                               , "SQL_NUMERIC"+                               , "SQL_ODBC_CURSORS"+                               , "SQL_REAL"+                               , "SQL_SMALLINT"+                               , "SQL_TIME"+                               , "SQL_TIMESTAMP"+                               , "SQL_TINYINT"+                               , "SQL_VARBINARY"+                               , "SQL_VARCHAR"+                               , "SQLITE3_ASSOC"+                               , "SQLITE3_BLOB"+                               , "SQLITE3_BOTH"+                               , "SQLITE3_FLOAT"+                               , "SQLITE3_INTEGER"+                               , "SQLITE3_NULL"+                               , "SQLITE3_NUM"+                               , "SQLITE3_OPEN_CREATE"+                               , "SQLITE3_OPEN_READONLY"+                               , "SQLITE3_OPEN_READWRITE"+                               , "SQLITE3_TEXT"+                               , "SQLITE_ABORT"+                               , "SQLITE_ASSOC"+                               , "SQLITE_AUTH"+                               , "SQLITE_BOTH"+                               , "SQLITE_BUSY"+                               , "SQLITE_CANTOPEN"+                               , "SQLITE_CONSTRAINT"+                               , "SQLITE_CORRUPT"+                               , "SQLITE_DONE"+                               , "SQLITE_EMPTY"+                               , "SQLITE_ERROR"+                               , "SQLITE_FORMAT"+                               , "SQLITE_FULL"+                               , "SQLITE_INTERNAL"+                               , "SQLITE_INTERRUPT"+                               , "SQLITE_IOERR"+                               , "SQLITE_LOCKED"+                               , "SQLITE_MISMATCH"+                               , "SQLITE_MISUSE"+                               , "SQLITE_NOLFS"+                               , "SQLITE_NOMEM"+                               , "SQLITE_NOTFOUND"+                               , "SQLITE_NUM"+                               , "SQLITE_OK"+                               , "SQLITE_PERM"+                               , "SQLITE_PROTOCOL"+                               , "SQLITE_READONLY"+                               , "SQLITE_ROW"+                               , "SQLITE_SCHEMA"+                               , "SQLITE_TOOBIG"+                               , "SQLT_AFC"+                               , "SQLT_AVC"+                               , "SQLT_BDOUBLE"+                               , "SQLT_BFILEE"+                               , "SQLT_BFLOAT"+                               , "SQLT_BIN"+                               , "SQLT_BLOB"+                               , "SQLT_CFILEE"+                               , "SQLT_CHR"+                               , "SQLT_CLOB"+                               , "SQLT_FLT"+                               , "SQLT_INT"+                               , "SQLT_LBI"+                               , "SQLT_LNG"+                               , "SQLT_LVC"+                               , "SQLT_NTY"+                               , "SQLT_NUM"+                               , "SQLT_ODT"+                               , "SQLT_RDD"+                               , "SQLT_RSET"+                               , "SQLT_STR"+                               , "SQLT_UIN"+                               , "SQLT_VCS"+                               , "ST_SET"+                               , "ST_SILENT"+                               , "ST_UID"+                               , "STDERR"+                               , "STDIN"+                               , "STDOUT"+                               , "STR_PAD_BOTH"+                               , "STR_PAD_LEFT"+                               , "STR_PAD_RIGHT"+                               , "STREAM_CLIENT_ASYNC_CONNECT"+                               , "STREAM_CLIENT_CONNECT"+                               , "STREAM_CLIENT_PERSISTENT"+                               , "STREAM_ENFORCE_SAFE_MODE"+                               , "STREAM_FILTER_ALL"+                               , "STREAM_FILTER_READ"+                               , "STREAM_FILTER_WRITE"+                               , "STREAM_IGNORE_URL"+                               , "STREAM_MKDIR_RECURSIVE"+                               , "STREAM_MUST_SEEK"+                               , "STREAM_NOTIFY_AUTH_REQUIRED"+                               , "STREAM_NOTIFY_AUTH_RESULT"+                               , "STREAM_NOTIFY_COMPLETED"+                               , "STREAM_NOTIFY_CONNECT"+                               , "STREAM_NOTIFY_FAILURE"+                               , "STREAM_NOTIFY_FILE_SIZE_IS"+                               , "STREAM_NOTIFY_MIME_TYPE_IS"+                               , "STREAM_NOTIFY_PROGRESS"+                               , "STREAM_NOTIFY_REDIRECTED"+                               , "STREAM_NOTIFY_RESOLVE"+                               , "STREAM_NOTIFY_SEVERITY_ERR"+                               , "STREAM_NOTIFY_SEVERITY_INFO"+                               , "STREAM_NOTIFY_SEVERITY_WARN"+                               , "STREAM_OOB"+                               , "STREAM_PEEK"+                               , "STREAM_REPORT_ERRORS"+                               , "STREAM_SERVER_BIND"+                               , "STREAM_SERVER_LISTEN"+                               , "STREAM_URL_STAT_LINK"+                               , "STREAM_URL_STAT_QUIET"+                               , "STREAM_USE_PATH"+                               , "SUNFUNCS_RET_DOUBLE"+                               , "SUNFUNCS_RET_STRING"+                               , "SUNFUNCS_RET_TIMESTAMP"+                               , "T_ABSTRACT"+                               , "T_AND_EQUAL"+                               , "T_ARRAY"+                               , "T_ARRAY_CAST"+                               , "T_AS"+                               , "T_BAD_CHARACTER"+                               , "T_BOOL_CAST"+                               , "T_BOOLEAN_AND"+                               , "T_BOOLEAN_OR"+                               , "T_BREAK"+                               , "T_CASE"+                               , "T_CATCH"+                               , "T_CHARACTER"+                               , "T_CLASS"+                               , "T_CLASS_C"+                               , "T_CLONE"+                               , "T_CLOSE_TAG"+                               , "T_COMMENT"+                               , "T_CONCAT_EQUAL"+                               , "T_CONST"+                               , "T_CONSTANT_ENCAPSED_STRING"+                               , "T_CONTINUE"+                               , "T_CURLY_OPEN"+                               , "T_DEC"+                               , "T_DECLARE"+                               , "T_DEFAULT"+                               , "T_DIV_EQUAL"+                               , "T_DNUMBER"+                               , "T_DO"+                               , "T_DOC_COMMENT"+                               , "T_DOLLAR_OPEN_CURLY_BRACES"+                               , "T_DOUBLE_ARROW"+                               , "T_DOUBLE_CAST"+                               , "T_DOUBLE_COLON"+                               , "T_ECHO"+                               , "T_ELSE"+                               , "T_ELSEIF"+                               , "T_EMPTY"+                               , "T_ENCAPSED_AND_WHITESPACE"+                               , "T_END_HEREDOC"+                               , "T_ENDDECLARE"+                               , "T_ENDFOR"+                               , "T_ENDFOREACH"+                               , "T_ENDIF"+                               , "T_ENDSWITCH"+                               , "T_ENDWHILE"+                               , "T_EVAL"+                               , "T_EXIT"+                               , "T_EXTENDS"+                               , "T_FILE"+                               , "T_FINAL"+                               , "T_FMT"+                               , "T_FMT_AMPM"+                               , "T_FOR"+                               , "T_FOREACH"+                               , "T_FUNC_C"+                               , "T_FUNCTION"+                               , "T_GLOBAL"+                               , "T_IF"+                               , "T_IMPLEMENTS"+                               , "T_INC"+                               , "T_INCLUDE"+                               , "T_INCLUDE_ONCE"+                               , "T_INLINE_HTML"+                               , "T_INSTANCEOF"+                               , "T_INT_CAST"+                               , "T_INTERFACE"+                               , "T_IS_EQUAL"+                               , "T_IS_GREATER_OR_EQUAL"+                               , "T_IS_IDENTICAL"+                               , "T_IS_NOT_EQUAL"+                               , "T_IS_NOT_IDENTICAL"+                               , "T_IS_SMALLER_OR_EQUAL"+                               , "T_ISSET"+                               , "T_LINE"+                               , "T_LIST"+                               , "T_LNUMBER"+                               , "T_LOGICAL_AND"+                               , "T_LOGICAL_OR"+                               , "T_LOGICAL_XOR"+                               , "T_METHOD_C"+                               , "T_MINUS_EQUAL"+                               , "T_MOD_EQUAL"+                               , "T_MUL_EQUAL"+                               , "T_NEW"+                               , "T_NUM_STRING"+                               , "T_OBJECT_CAST"+                               , "T_OBJECT_OPERATOR"+                               , "T_OPEN_TAG"+                               , "T_OPEN_TAG_WITH_ECHO"+                               , "T_OR_EQUAL"+                               , "T_PAAMAYIM_NEKUDOTAYIM"+                               , "T_PLUS_EQUAL"+                               , "T_PRINT"+                               , "T_PRIVATE"+                               , "T_PROTECTED"+                               , "T_PUBLIC"+                               , "T_REQUIRE"+                               , "T_REQUIRE_ONCE"+                               , "T_RETURN"+                               , "T_SL"+                               , "T_SL_EQUAL"+                               , "T_SR"+                               , "T_SR_EQUAL"+                               , "T_START_HEREDOC"+                               , "T_STATIC"+                               , "T_STRING"+                               , "T_STRING_CAST"+                               , "T_STRING_VARNAME"+                               , "T_SWITCH"+                               , "T_THROW"+                               , "T_TRY"+                               , "T_UNSET"+                               , "T_UNSET_CAST"+                               , "T_USE"+                               , "T_VAR"+                               , "T_VARIABLE"+                               , "T_WHILE"+                               , "T_WHITESPACE"+                               , "T_XOR_EQUAL"+                               , "THOUSEP"+                               , "true"+                               , "TYPEAPPLICATION"+                               , "TYPEAUDIO"+                               , "TYPEIMAGE"+                               , "TYPEMESSAGE"+                               , "TYPEMODEL"+                               , "TYPEMULTIPART"+                               , "TYPEOTHER"+                               , "TYPETEXT"+                               , "TYPEVIDEO"+                               , "UNKNOWN_TYPE"+                               , "UPLOAD_ERR_CANT_WRITE"+                               , "UPLOAD_ERR_FORM_SIZE"+                               , "UPLOAD_ERR_INI_SIZE"+                               , "UPLOAD_ERR_NO_FILE"+                               , "UPLOAD_ERR_NO_TMP_DIR"+                               , "UPLOAD_ERR_OK"+                               , "UPLOAD_ERR_PARTIAL"+                               , "WNOHANG"+                               , "WUNTRACED"+                               , "X509_PURPOSE_ANY"+                               , "X509_PURPOSE_CRL_SIGN"+                               , "X509_PURPOSE_NS_SSL_SERVER"+                               , "X509_PURPOSE_SMIME_ENCRYPT"+                               , "X509_PURPOSE_SMIME_SIGN"+                               , "X509_PURPOSE_SSL_CLIENT"+                               , "X509_PURPOSE_SSL_SERVER"+                               , "XML_ATTRIBUTE_CDATA"+                               , "XML_ATTRIBUTE_DECL_NODE"+                               , "XML_ATTRIBUTE_ENTITY"+                               , "XML_ATTRIBUTE_ENUMERATION"+                               , "XML_ATTRIBUTE_ID"+                               , "XML_ATTRIBUTE_IDREF"+                               , "XML_ATTRIBUTE_IDREFS"+                               , "XML_ATTRIBUTE_NMTOKEN"+                               , "XML_ATTRIBUTE_NMTOKENS"+                               , "XML_ATTRIBUTE_NODE"+                               , "XML_ATTRIBUTE_NOTATION"+                               , "XML_CDATA_SECTION_NODE"+                               , "XML_COMMENT_NODE"+                               , "XML_DOCUMENT_FRAG_NODE"+                               , "XML_DOCUMENT_NODE"+                               , "XML_DOCUMENT_TYPE_NODE"+                               , "XML_DTD_NODE"+                               , "XML_ELEMENT_DECL_NODE"+                               , "XML_ELEMENT_NODE"+                               , "XML_ENTITY_DECL_NODE"+                               , "XML_ENTITY_NODE"+                               , "XML_ENTITY_REF_NODE"+                               , "XML_ERROR_ASYNC_ENTITY"+                               , "XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF"+                               , "XML_ERROR_BAD_CHAR_REF"+                               , "XML_ERROR_BINARY_ENTITY_REF"+                               , "XML_ERROR_DUPLICATE_ATTRIBUTE"+                               , "XML_ERROR_EXTERNAL_ENTITY_HANDLING"+                               , "XML_ERROR_INCORRECT_ENCODING"+                               , "XML_ERROR_INVALID_TOKEN"+                               , "XML_ERROR_JUNK_AFTER_DOC_ELEMENT"+                               , "XML_ERROR_MISPLACED_XML_PI"+                               , "XML_ERROR_NO_ELEMENTS"+                               , "XML_ERROR_NO_MEMORY"+                               , "XML_ERROR_NONE"+                               , "XML_ERROR_PARAM_ENTITY_REF"+                               , "XML_ERROR_PARTIAL_CHAR"+                               , "XML_ERROR_RECURSIVE_ENTITY_REF"+                               , "XML_ERROR_SYNTAX"+                               , "XML_ERROR_TAG_MISMATCH"+                               , "XML_ERROR_UNCLOSED_CDATA_SECTION"+                               , "XML_ERROR_UNCLOSED_TOKEN"+                               , "XML_ERROR_UNDEFINED_ENTITY"+                               , "XML_ERROR_UNKNOWN_ENCODING"+                               , "XML_HTML_DOCUMENT_NODE"+                               , "XML_LOCAL_NAMESPACE"+                               , "XML_NAMESPACE_DECL_NODE"+                               , "XML_NOTATION_NODE"+                               , "XML_OPTION_CASE_FOLDING"+                               , "XML_OPTION_SKIP_TAGSTART"+                               , "XML_OPTION_SKIP_WHITE"+                               , "XML_OPTION_TARGET_ENCODING"+                               , "XML_PI_NODE"+                               , "XML_SAX_IMPL"+                               , "XML_TEXT_NODE"+                               , "XSD_1999_NAMESPACE"+                               , "XSD_1999_TIMEINSTANT"+                               , "XSD_ANYTYPE"+                               , "XSD_ANYURI"+                               , "XSD_BASE64BINARY"+                               , "XSD_BOOLEAN"+                               , "XSD_BYTE"+                               , "XSD_DATE"+                               , "XSD_DATETIME"+                               , "XSD_DECIMAL"+                               , "XSD_DOUBLE"+                               , "XSD_DURATION"+                               , "XSD_ENTITIES"+                               , "XSD_ENTITY"+                               , "XSD_FLOAT"+                               , "XSD_GDAY"+                               , "XSD_GMONTH"+                               , "XSD_GMONTHDAY"+                               , "XSD_GYEAR"+                               , "XSD_GYEARMONTH"+                               , "XSD_HEXBINARY"+                               , "XSD_ID"+                               , "XSD_IDREF"+                               , "XSD_IDREFS"+                               , "XSD_INT"+                               , "XSD_INTEGER"+                               , "XSD_LANGUAGE"+                               , "XSD_LONG"+                               , "XSD_NAME"+                               , "XSD_NAMESPACE"+                               , "XSD_NCNAME"+                               , "XSD_NEGATIVEINTEGER"+                               , "XSD_NMTOKEN"+                               , "XSD_NMTOKENS"+                               , "XSD_NONNEGATIVEINTEGER"+                               , "XSD_NONPOSITIVEINTEGER"+                               , "XSD_NORMALIZEDSTRING"+                               , "XSD_NOTATION"+                               , "XSD_POSITIVEINTEGER"+                               , "XSD_QNAME"+                               , "XSD_SHORT"+                               , "XSD_STRING"+                               , "XSD_TIME"+                               , "XSD_TOKEN"+                               , "XSD_UNSIGNEDBYTE"+                               , "XSD_UNSIGNEDINT"+                               , "XSD_UNSIGNEDLONG"+                               , "XSD_UNSIGNEDSHORT"+                               , "XSL_CLONE_ALWAYS"+                               , "XSL_CLONE_AUTO"+                               , "XSL_CLONE_NEVER"+                               , "YESEXPR"+                               , "YPERR_BADARGS"+                               , "YPERR_BADDB"+                               , "YPERR_BUSY"+                               , "YPERR_DOMAIN"+                               , "YPERR_KEY"+                               , "YPERR_MAP"+                               , "YPERR_NODOM"+                               , "YPERR_NOMORE"+                               , "YPERR_PMAP"+                               , "YPERR_RESRC"+                               , "YPERR_RPC"+                               , "YPERR_VERS"+                               , "YPERR_YPBIND"+                               , "YPERR_YPERR"+                               , "YPERR_YPSERV"+                               , "ZEND_THREAD_SAFE"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[A-Z_][A-Z_0-9]*\\b"+                              , reCompiled = Just (compileRegex True "\\b[A-Z_][A-Z_0-9]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\(\\s*(int|integer|bool|boolean|float|double|real|string|array|object)\\s*\\)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\(\\s*(int|integer|bool|boolean|float|double|real|string|array|object)\\s*\\)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "doublequotestring" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "backquotestring" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "singlequotestring" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<<<\"((EO)?HTML)\""+                              , reCompiled = Just (compileRegex True "<<<\"((EO)?HTML)\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "htmlheredoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<<<\"((EO)?CSS)\""+                              , reCompiled = Just (compileRegex True "<<<\"((EO)?CSS)\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "cssheredoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<<<\"((EO)?JAVASCRIPT)\""+                              , reCompiled = Just (compileRegex True "<<<\"((EO)?JAVASCRIPT)\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "javascriptheredoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<<<\"((EO)?MYSQL)\""+                              , reCompiled = Just (compileRegex True "<<<\"((EO)?MYSQL)\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "mysqlheredoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<<<\"([A-Za-z_][A-Za-z0-9_]*)\""+                              , reCompiled =+                                  Just (compileRegex True "<<<\"([A-Za-z_][A-Za-z0-9_]*)\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "heredoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<<<((EO)?HTML)\\b"+                              , reCompiled = Just (compileRegex True "<<<((EO)?HTML)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "htmlheredoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<<<((EO)?CSS)\\b"+                              , reCompiled = Just (compileRegex True "<<<((EO)?CSS)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "cssheredoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<<<((EO)?JAVASCRIPT)\\b"+                              , reCompiled = Just (compileRegex True "<<<((EO)?JAVASCRIPT)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "javascriptheredoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<<<((EO)?MYSQL)\\b"+                              , reCompiled = Just (compileRegex True "<<<((EO)?MYSQL)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "mysqlheredoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<<<([A-Za-z_][A-Za-z0-9_]*)"+                              , reCompiled =+                                  Just (compileRegex True "<<<([A-Za-z_][A-Za-z0-9_]*)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "heredoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<<<'((EO)?HTML)'"+                              , reCompiled = Just (compileRegex True "<<<'((EO)?HTML)'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "htmlnowdoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<<<'((EO)?CSS)'"+                              , reCompiled = Just (compileRegex True "<<<'((EO)?CSS)'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "cssnowdoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<<<'((EO)?JAVASCRIPT)'"+                              , reCompiled = Just (compileRegex True "<<<'((EO)?JAVASCRIPT)'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "javascriptnowdoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<<<'((EO)?MYSQL)'"+                              , reCompiled = Just (compileRegex True "<<<'((EO)?MYSQL)'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "mysqlnowdoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<<<'([A-Za-z_][A-Za-z0-9_]*)'"+                              , reCompiled =+                                  Just (compileRegex True "<<<'([A-Za-z_][A-Za-z0-9_]*)'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "nowdoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?@[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "$_COOKIE"+                               , "$_ENV"+                               , "$_FILES"+                               , "$_GET"+                               , "$_POST"+                               , "$_REQUEST"+                               , "$_SERVER"+                               , "$_SESSION"+                               , "$GLOBALS"+                               , "$php_errormsg"+                               , "$this"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$+[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\$+[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[0123456789]*\\.\\.\\.[0123456789]*"+                              , reCompiled =+                                  Just (compileRegex True "[0123456789]*\\.\\.\\.[0123456789]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "0[bB][01]+"+                              , reCompiled = Just (compileRegex True "0[bB][01]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar ";(),[]"+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "singlequotestring"+          , Context+              { cName = "singlequotestring"+              , cSyntax = "PHP/PHP"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '\''+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "start"+          , Context+              { cName = "start"+              , cSyntax = "PHP/PHP"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\?(?:=|php)?"+                              , reCompiled = Just (compileRegex False "<\\?(?:=|php)?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PHP/PHP" , "phpsource" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "?>"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Push ( "PHP/PHP" , "phpsource" ) ]+              , cDynamic = False+              }+          )+        , ( "ternary"+          , Context+              { cName = "ternary"+              , cSyntax = "PHP/PHP"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars ':' ':'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "PHP/PHP" , "phpsource" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "twolinecomment"+          , Context+              { cName = "twolinecomment"+              , cSyntax = "PHP/PHP"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = ""+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = []+  , sStartingContext = "start"+  }
+ src/Skylighting/Syntax/Pike.hs view
@@ -0,0 +1,690 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Pike (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Pike"+  , sFilename = "pike.xml"+  , sShortname = "Pike"+  , sContexts =+      fromList+        [ ( "Block Comment"+          , Context+              { cName = "Block Comment"+              , cSyntax = "Pike"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(FIXME|TODO|NOT(IC)?E):?"+                              , reCompiled = Just (compileRegex True "(FIXME|TODO|NOT(IC)?E):?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Line Comment"+          , Context+              { cName = "Line Comment"+              , cSyntax = "Pike"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(FIXME|TODO|NOT(IC)?E):?"+                              , reCompiled = Just (compileRegex True "(FIXME|TODO|NOT(IC)?E):?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Pike"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "break"+                               , "case"+                               , "class"+                               , "continue"+                               , "default"+                               , "do"+                               , "else"+                               , "for"+                               , "foreach"+                               , "if"+                               , "return"+                               , "switch"+                               , "while"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "array"+                               , "float"+                               , "function"+                               , "int"+                               , "mapping"+                               , "mixed"+                               , "multiset>"+                               , "object"+                               , "program"+                               , "static"+                               , "string"+                               , "void"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "catch" , "gauge" , "sscanf" , "typeof" ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "`([\\+\\-\\*/%~&\\|^]|[!=<>]=|<<?|>>?|(\\[\\]|->)=?)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "`([\\+\\-\\*/%~&\\|^]|[!=<>]=|<<?|>>?|(\\[\\]|->)=?)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "0[bB][01]+"+                              , reCompiled = Just (compileRegex True "0[bB][01]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pike" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pike" , "Line Comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '!'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pike" , "Line Comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pike" , "Block Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*if\\s+0"+                              , reCompiled = Just (compileRegex True "#\\s*if\\s+0")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pike" , "Outscoped" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pike" , "Preprocessor" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Outscoped"+          , Context+              { cName = "Outscoped"+              , cSyntax = "Pike"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(FIXME|TODO|NOT(IC)?E):?"+                              , reCompiled = Just (compileRegex True "(FIXME|TODO|NOT(IC)?E):?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pike" , "Block Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*if"+                              , reCompiled = Just (compileRegex True "#\\s*if")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pike" , "Outscoped intern" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*(endif|elif|else)"+                              , reCompiled = Just (compileRegex True "#\\s*(endif|elif|else)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Outscoped intern"+          , Context+              { cName = "Outscoped intern"+              , cSyntax = "Pike"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pike" , "Block Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*if"+                              , reCompiled = Just (compileRegex True "#\\s*if")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pike" , "Outscoped intern" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*endif"+                              , reCompiled = Just (compileRegex True "#\\s*endif")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Preprocessor"+          , Context+              { cName = "Preprocessor"+              , cSyntax = "Pike"+              , cRules =+                  [ Rule+                      { rMatcher = RangeDetect '"' '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = RangeDetect '<' '>'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pike" , "Line Comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pike" , "Block Comment" ) ]+                      }+                  , Rule+                      { rMatcher = LineContinue+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Pike"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\d[0-9]+"+                              , reCompiled = Just (compileRegex True "\\\\d[0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Paul Pogonyshev"+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.pike" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Postscript.hs view
@@ -0,0 +1,585 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Postscript (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "PostScript"+  , sFilename = "postscript.xml"+  , sShortname = "Postscript"+  , sContexts =+      fromList+        [ ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "PostScript"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Header"+          , Context+              { cName = "Header"+              , cSyntax = "PostScript"+              , cRules = []+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "PostScript"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "abs"+                               , "add"+                               , "aload"+                               , "anchorsearch"+                               , "and"+                               , "arc"+                               , "arcn"+                               , "arct"+                               , "arcto"+                               , "array"+                               , "ASCII85Decode"+                               , "ASCII85Encode"+                               , "ASCIIHexDecode"+                               , "ASCIIHexEncode"+                               , "ashow"+                               , "astore"+                               , "atan"+                               , "awidthshow"+                               , "banddevice"+                               , "begin"+                               , "bind"+                               , "bitshift"+                               , "bytesavailable"+                               , "cachestatus"+                               , "CCITTFaxDecode"+                               , "CCITTFaxEncode"+                               , "ceiling"+                               , "charpath"+                               , "CIEBasedA"+                               , "CIEBasedABC"+                               , "CIEBasedDEF"+                               , "CIEBasedDEFG"+                               , "clear"+                               , "cleardictstack"+                               , "cleartomark"+                               , "clip"+                               , "clippath"+                               , "closefile"+                               , "closepath"+                               , "colorimage"+                               , "concat"+                               , "concatmatrix"+                               , "condition"+                               , "copy"+                               , "copypage"+                               , "cos"+                               , "count"+                               , "countdictstack"+                               , "countexecstack"+                               , "counttomark"+                               , "Courier"+                               , "Courier-Bold"+                               , "Courier-BoldOblique"+                               , "Courier-Oblique"+                               , "cshow"+                               , "currentblackgeneration"+                               , "currentcacheparams"+                               , "currentcmykcolor"+                               , "currentcolor"+                               , "currentcolorrendering"+                               , "currentcolorscreen"+                               , "currentcolorspace"+                               , "currentcolortransfer"+                               , "currentcontext"+                               , "currentdash"+                               , "currentdevparams"+                               , "currentdict"+                               , "currentfile"+                               , "currentflat"+                               , "currentfont"+                               , "currentglobal"+                               , "currentgray"+                               , "currentgstate"+                               , "currenthalftone"+                               , "currenthalftonephase"+                               , "currenthsbcolor"+                               , "currentlinecap"+                               , "currentlinejoin"+                               , "currentlinewidth"+                               , "currentmatrix"+                               , "currentmiterlimit"+                               , "currentobjectformat"+                               , "currentoverprint"+                               , "currentpacking"+                               , "currentpagedevice"+                               , "currentpoint"+                               , "currentrgbcolor"+                               , "currentscreen"+                               , "currentshared"+                               , "currentstrokeadjust"+                               , "currentsystemparams"+                               , "currenttransfer"+                               , "currentundercolorremoval"+                               , "currentuserparams"+                               , "curveto"+                               , "cvi"+                               , "cvlit"+                               , "cvn"+                               , "cvr"+                               , "cvrs"+                               , "cvs"+                               , "cvx"+                               , "DCTDecode"+                               , "DCTEncode"+                               , "def"+                               , "defaultmatrix"+                               , "definefont"+                               , "defineresource"+                               , "defineusername"+                               , "defineuserobject"+                               , "deletefile"+                               , "detach"+                               , "DeviceCMYK"+                               , "DeviceGray"+                               , "deviceinfo"+                               , "DeviceN"+                               , "DeviceRGB"+                               , "dict"+                               , "dictstack"+                               , "div"+                               , "dtransform"+                               , "dup"+                               , "echo"+                               , "end"+                               , "eoclip"+                               , "eofill"+                               , "eoviewclip"+                               , "eq"+                               , "erasepage"+                               , "errordict"+                               , "exch"+                               , "exec"+                               , "execform"+                               , "execstack"+                               , "execuserobject"+                               , "executeonly"+                               , "exit"+                               , "exp"+                               , "false"+                               , "file"+                               , "filenameforall"+                               , "fileposition"+                               , "fill"+                               , "filter"+                               , "findencoding"+                               , "findfont"+                               , "findresource"+                               , "flattenpath"+                               , "floor"+                               , "flush"+                               , "flushfile"+                               , "FontDirectory"+                               , "for"+                               , "forall"+                               , "fork"+                               , "framedevice"+                               , "gcheck"+                               , "ge"+                               , "get"+                               , "getinterval"+                               , "globaldict"+                               , "GlobalFontDirectory"+                               , "glyphshow"+                               , "grestore"+                               , "grestoreall"+                               , "gsave"+                               , "gstate"+                               , "gt"+                               , "handleerror"+                               , "Helvetica"+                               , "Helvetica-Bold"+                               , "Helvetica-BoldOblique"+                               , "Helvetica-Oblique"+                               , "identmatrix"+                               , "idiv"+                               , "idtransform"+                               , "if"+                               , "ifelse"+                               , "image"+                               , "imagemask"+                               , "index"+                               , "Indexed"+                               , "ineofill"+                               , "infill"+                               , "initclip"+                               , "initgraphics"+                               , "initmatrix"+                               , "initviewclip"+                               , "instroke"+                               , "inueofill"+                               , "inufill"+                               , "inustroke"+                               , "invertmatrix"+                               , "ISOLatin1Encoding"+                               , "itransform"+                               , "join"+                               , "known"+                               , "kshow"+                               , "languagelevel"+                               , "le"+                               , "length"+                               , "lineto"+                               , "ln"+                               , "load"+                               , "lock"+                               , "log"+                               , "loop"+                               , "lt"+                               , "LZWDecode"+                               , "LZWEncode"+                               , "makefont"+                               , "makepattern"+                               , "mark"+                               , "matrix"+                               , "maxlength"+                               , "mod"+                               , "monitor"+                               , "moveto"+                               , "mul"+                               , "ne"+                               , "neg"+                               , "newpath"+                               , "noaccess"+                               , "not"+                               , "notify"+                               , "null"+                               , "nulldevice"+                               , "NullEncode"+                               , "or"+                               , "packedarray"+                               , "pathbbox"+                               , "pathforall"+                               , "Pattern"+                               , "pop"+                               , "print"+                               , "printobject"+                               , "product"+                               , "pstack"+                               , "put"+                               , "putinterval"+                               , "quit"+                               , "rand"+                               , "rcheck"+                               , "rcurveto"+                               , "read"+                               , "readhexstring"+                               , "readline"+                               , "readonly"+                               , "readstring"+                               , "realtime"+                               , "rectclip"+                               , "rectfill"+                               , "rectstroke"+                               , "rectviewclip"+                               , "renamefile"+                               , "renderbands"+                               , "repeat"+                               , "resetfile"+                               , "resourceforall"+                               , "resourcestatus"+                               , "restore"+                               , "reversepath"+                               , "revision"+                               , "rlineto"+                               , "rmoveto"+                               , "roll"+                               , "rootfont"+                               , "rotate"+                               , "round"+                               , "rrand"+                               , "run"+                               , "RunLengthDecode"+                               , "RunLengthEncode"+                               , "save"+                               , "scale"+                               , "scalefont"+                               , "scheck"+                               , "search"+                               , "selectfont"+                               , "Separation"+                               , "serialnumber"+                               , "setbbox"+                               , "setblackgeneration"+                               , "setcachedevice"+                               , "setcachedevice2"+                               , "setcachelimit"+                               , "setcacheparams"+                               , "setcharwidth"+                               , "setcmykcolor"+                               , "setcolor"+                               , "setcolorrendering"+                               , "setcolorscreen"+                               , "setcolorspace"+                               , "setcolortransfer"+                               , "setdash"+                               , "setdevparams"+                               , "setfileposition"+                               , "setflat"+                               , "setfont"+                               , "setglobal"+                               , "setgray"+                               , "setgstate"+                               , "sethalftone"+                               , "sethalftonephase"+                               , "sethsbcolor"+                               , "setlinecap"+                               , "setlinejoin"+                               , "setlinewidth"+                               , "setmatrix"+                               , "setmiterlimit"+                               , "setobjectformat"+                               , "setoverprint"+                               , "setpacking"+                               , "setpagedevice"+                               , "setpattern"+                               , "setrgbcolor"+                               , "setscreen"+                               , "setshared"+                               , "setstrokeadjust"+                               , "setsystemparams"+                               , "settransfer"+                               , "setucacheparams"+                               , "setundercolorremoval"+                               , "setuserparams"+                               , "setvmthreshold"+                               , "shareddict"+                               , "SharedFontDirectory"+                               , "show"+                               , "showpage"+                               , "sin"+                               , "sqrt"+                               , "srand"+                               , "stack"+                               , "StandardEncoding"+                               , "startjob"+                               , "status"+                               , "statusdict"+                               , "stop"+                               , "stopped"+                               , "store"+                               , "string"+                               , "stringwidth"+                               , "stroke"+                               , "strokepath"+                               , "sub"+                               , "SubFileDecode"+                               , "Symbol"+                               , "systemdict"+                               , "Times-Bold"+                               , "Times-BoldItalic"+                               , "Times-Italic"+                               , "Times-Roman"+                               , "token"+                               , "transform"+                               , "translate"+                               , "true"+                               , "truncate"+                               , "type"+                               , "uappend"+                               , "ucache"+                               , "ucachestatus"+                               , "ueofill"+                               , "ufill"+                               , "undef"+                               , "undefinefont"+                               , "undefineresource"+                               , "undefineuserobject"+                               , "upath"+                               , "userdict"+                               , "UserObjects"+                               , "usertime"+                               , "ustroke"+                               , "ustrokepath"+                               , "version"+                               , "viewclip"+                               , "viewclippath"+                               , "vmreclaim"+                               , "vmstatus"+                               , "wait"+                               , "wcheck"+                               , "where"+                               , "widthshow"+                               , "write"+                               , "writehexstring"+                               , "writeobject"+                               , "writestring"+                               , "wtranslation"+                               , "xcheck"+                               , "xor"+                               , "xshow"+                               , "xyshow"+                               , "yield"+                               , "yshow"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '%' '!'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PostScript" , "Header" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PostScript" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PostScript" , "String" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\/{1,2}[^\\s\\(\\)\\{\\}\\[\\]%/]*"+                              , reCompiled =+                                  Just (compileRegex True "\\/{1,2}[^\\s\\(\\)\\{\\}\\[\\]%/]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "PostScript"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = ""+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.ps" , "*.ai" , "*.eps" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Prolog.hs view
@@ -0,0 +1,3560 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Prolog (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Prolog"+  , sFilename = "prolog.xml"+  , sShortname = "Prolog"+  , sContexts =+      fromList+        [ ( "1-comment"+          , Context+              { cName = "1-comment"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts_indent" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "arith_expr"+          , Context+              { cName = "arith_expr"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "nested_expr" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '!'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '|'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.(?!(\\(|[#$&*+\\-./:<=>?@^~\\\\]))"+                              , reCompiled =+                                  Just (compileRegex True "\\.(?!(\\(|[#$&*+\\-./:<=>?@^~\\\\]))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(;|->|\\\\\\+|:-|=|\\\\=)(?![#$&*+\\-./:<=>?@^~\\\\])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(;|->|\\\\\\+|:-|=|\\\\=)(?![#$&*+\\-./:<=>?@^~\\\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Prolog" , "arith_expr_common" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "arith_expr_common"+          , Context+              { cName = "arith_expr_common"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Prolog" , "layout" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Prolog" , "number" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"#$%&'()*+,-./:;<=>?[\\]^`{|}~"+                              }+                            (makeWordSet True [ "is" ])+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"#$%&'()*+,-./:;<=>?[\\]^`{|}~"+                              }+                            (makeWordSet+                               True+                               [ "atan"+                               , "char_conversion"+                               , "current_char_conversion"+                               , "ensure_loaded"+                               , "include"+                               , "xor"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"#$%&'()*+,-./:;<=>?[\\]^`{|}~"+                              }+                            (makeWordSet True [ "abs" , "max" , "min" , "sign" ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"#$%&'()*+,-./:;<=>?[\\]^`{|}~"+                              }+                            (makeWordSet True [ "ceiling" , "floor" , "round" , "truncate" ])+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"#$%&'()*+,-./:;<=>?[\\]^`{|}~"+                              }+                            (makeWordSet+                               True+                               [ "acos"+                               , "asin"+                               , "atan2"+                               , "cos"+                               , "exp"+                               , "float"+                               , "float_fractional_part"+                               , "float_integer_part"+                               , "log"+                               , "pi"+                               , "sin"+                               , "sqrt"+                               , "tan"+                               ])+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"#$%&'()*+,-./:;<=>?[\\]^`{|}~"+                              }+                            (makeWordSet True [ "div" , "mod" , "rem" ])+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(=:=|=\\\\=|=<|<|>=|>)(?![#$&*+\\-./:<=>?@^~\\\\])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(=:=|=\\\\=|=<|<|>=|>)(?![#$&*+\\-./:<=>?@^~\\\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\+|-|\\*|\\^)(?![#$&*+\\-./:<=>?@^~\\\\])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(\\+|-|\\*|\\^)(?![#$&*+\\-./:<=>?@^~\\\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "//(?![#$&*+\\-./:<=>?@^~\\\\])"+                              , reCompiled =+                                  Just (compileRegex True "//(?![#$&*+\\-./:<=>?@^~\\\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(/|\\*\\*)(?![#$&*+\\-./:<=>?@^~\\\\])"+                              , reCompiled =+                                  Just (compileRegex True "(/|\\*\\*)(?![#$&*+\\-./:<=>?@^~\\\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(/\\\\|\\\\/|\\\\|<<|>>)(?![#$&*+\\-./:<=>?@^~\\\\])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(/\\\\|\\\\/|\\\\|<<|>>)(?![#$&*+\\-./:<=>?@^~\\\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Prolog" , "operator" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "abcdefghijklmnopqrstuvwxyz"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "id" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "ABCDEFGHIJKLMNOPQRSTUVWXYZ_"+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "var" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "#$&*+-./:<=>?@^~\\"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "graphic" ) ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "atomic"+          , Context+              { cName = "atomic"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"#$%&'()*+,-./:;<=>?[\\]^`{|}~"+                              }+                            (makeWordSet+                               True+                               [ "call"+                               , "catch"+                               , "fail"+                               , "false"+                               , "initialization"+                               , "once"+                               , "repeat"+                               , "throw"+                               , "true"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"#$%&'()*+,-./:;<=>?[\\]^`{|}~"+                              }+                            (makeWordSet+                               True+                               [ "atom"+                               , "atomic"+                               , "callable"+                               , "compound"+                               , "float"+                               , "ground"+                               , "integer"+                               , "nonvar"+                               , "number"+                               , "var"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"#$%&'()*+,-./:;<=>?[\\]^`{|}~"+                              }+                            (makeWordSet+                               True+                               [ "abolish"+                               , "asserta"+                               , "assertz"+                               , "clause"+                               , "dynamic"+                               , "retract"+                               , "retractall"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"#$%&'()*+,-./:;<=>?[\\]^`{|}~"+                              }+                            (makeWordSet+                               True+                               [ "get_byte"+                               , "get_char"+                               , "get_code"+                               , "nl"+                               , "open"+                               , "peek_byte"+                               , "peek_char"+                               , "peek_code"+                               , "put_byte"+                               , "put_char"+                               , "put_code"+                               , "read"+                               , "read_term"+                               , "set_stream_position"+                               , "write"+                               , "write_canonical"+                               , "writeq"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"#$%&'()*+,-./:;<=>?[\\]^`{|}~"+                              }+                            (makeWordSet+                               True+                               [ "acyclic_term"+                               , "arg"+                               , "atom_chars"+                               , "atom_codes"+                               , "atom_concat"+                               , "atom_length"+                               , "char_code"+                               , "compare"+                               , "copy_term"+                               , "functor"+                               , "number_chars"+                               , "number_codes"+                               , "subsumes_term"+                               , "term_variables"+                               , "unify_with_occurs_check"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"#$%&'()*+,-./:;<=>?[\\]^`{|}~"+                              }+                            (makeWordSet+                               True [ "discontigous" , "multifile" , "op" , "set_prolog_flag" ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"#$%&'()*+,-./:;<=>?[\\]^`{|}~"+                              }+                            (makeWordSet True [ "phrase" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"#$%&'()*+,-./:;<=>?[\\]^`{|}~"+                              }+                            (makeWordSet True [ "is" ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "arith_expr" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"#$%&'()*+,-./:;<=>?[\\]^`{|}~"+                              }+                            (makeWordSet+                               True+                               [ "at_end_of_stream"+                               , "close"+                               , "current_input"+                               , "current_op"+                               , "current_output"+                               , "current_prolog_flag"+                               , "flush_output"+                               , "set_input"+                               , "set_output"+                               , "stream_property"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"#$%&'()*+,-./:;<=>?[\\]^`{|}~"+                              }+                            (makeWordSet True [ "error" ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"#$%&'()*+,-./:;<=>?[\\]^`{|}~"+                              }+                            (makeWordSet+                               True+                               [ "domain_error"+                               , "evaluation_error"+                               , "existence_error"+                               , "instantiation_error"+                               , "permission_error"+                               , "representation_error"+                               , "resource_error"+                               , "syntax_error"+                               , "system_error"+                               , "type_error"+                               , "uninstantiation_error"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"#$%&'()*+,-./:;<=>?[\\]^`{|}~"+                              }+                            (makeWordSet+                               True+                               [ "atan"+                               , "char_conversion"+                               , "current_char_conversion"+                               , "ensure_loaded"+                               , "include"+                               , "xor"+                               ])+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Prolog" , "number" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "single-quoted" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "back-quoted" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "double-quoted" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Prolog" , "operator" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "abcdefghijklmnopqrstuvwxyz"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "id" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "ABCDEFGHIJKLMNOPQRSTUVWXYZ_"+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "var" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "#$&*+-./:<=>?@^~\\"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "graphic" ) ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "back-quoted"+          , Context+              { cName = "back-quoted"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "`$"+                              , reCompiled = Just (compileRegex True "`$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "bq" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "bq" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "bin"+          , Context+              { cName = "bin"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = AnyChar "01"+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "bq"+          , Context+              { cName = "bq"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Prolog" , "quoted_1st" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(``|\\\\[0-7]+\\\\|\\\\x[a-fA-F0-9]+\\\\|\\\\.|[^`\\\\]+)$"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(``|\\\\[0-7]+\\\\|\\\\x[a-fA-F0-9]+\\\\|\\\\.|[^`\\\\]+)$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "syntax_error_bq" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '`' '`'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Prolog" , "quoted_last" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "char_code"+          , Context+              { cName = "char_code"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\'' '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "esc_seq_cc" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ' '+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "clause"+          , Context+              { cName = "clause"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Prolog" , "layout" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.(?!(\\(|[#$&*+\\-./:<=>?@^~\\\\]))"+                              , reCompiled =+                                  Just (compileRegex True "\\.(?!(\\(|[#$&*+\\-./:<=>?@^~\\\\]))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "term" ) ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "comment-iso"+          , Context+              { cName = "comment-iso"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts_indent" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "curly"+          , Context+              { cName = "curly"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Prolog" , "layout" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "list" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "curly" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '!'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '|'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '.' '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "list_functor" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Prolog" , "atomic" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "double-quoted"+          , Context+              { cName = "double-quoted"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"$"+                              , reCompiled = Just (compileRegex True "\"$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "dq" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "dq" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "dq"+          , Context+              { cName = "dq"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Prolog" , "quoted_1st" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\"\"|\\\\[0-7]+\\\\|\\\\x[a-fA-F0-9]+\\\\|\\\\.|[^\"\\\\]+)$"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(\"\"|\\\\[0-7]+\\\\|\\\\x[a-fA-F0-9]+\\\\|\\\\.|[^\"\\\\]+)$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "syntax_error_dq" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '"' '"'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Prolog" , "quoted_last" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "esc_seq_cc"+          , Context+              { cName = "esc_seq_cc"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ' '+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = AnyChar "abfnrtv\\'`\"]"+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "esc_seq_q"+          , Context+              { cName = "esc_seq_q"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[0-7]+\\\\"+                              , reCompiled = Just (compileRegex True "\\\\[0-7]+\\\\")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\x[a-fA-F0-9]+\\\\"+                              , reCompiled = Just (compileRegex True "\\\\x[a-fA-F0-9]+\\\\")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "esc_seq_q2" ) ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Prolog" , "syntax_error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "esc_seq_q2"+          , Context+              { cName = "esc_seq_q2"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ' '+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = AnyChar "abfnrtv\\'`\"]"+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Prolog" , "syntax_error" ) ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop , Pop ]+              , cDynamic = False+              }+          )+        , ( "graphic"+          , Context+              { cName = "graphic"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = AnyChar "#$&*+-./:<=>?@^~\\"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "hex"+          , Context+              { cName = "hex"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = AnyChar "0123456789abcdefABCDEF"+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "id"+          , Context+              { cName = "id"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "layout"+          , Context+              { cName = "layout"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "comment-iso" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "%BEGIN"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "region_marker" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "%END"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "region_marker" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "layout_fold" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "1-comment" ) ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "layout_fold"+          , Context+              { cName = "layout_fold"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "%BEGIN"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "region_marker" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "%END"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "region_marker" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "1-comment" ) ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "list"+          , Context+              { cName = "list"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Prolog" , "layout" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "list" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "curly" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '!'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '|'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '.' '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "list_functor" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Prolog" , "atomic" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "list_functor"+          , Context+              { cName = "list_functor"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '.'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Prolog" , "syntax_error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "nested"+          , Context+              { cName = "nested"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Prolog" , "layout" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "list" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "curly" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '!'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '|'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '.' '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "list_functor" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.(?!(\\(|[#$&*+\\-./:<=>?@^~\\\\]))"+                              , reCompiled =+                                  Just (compileRegex True "\\.(?!(\\(|[#$&*+\\-./:<=>?@^~\\\\]))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Prolog" , "atomic" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "nested_expr"+          , Context+              { cName = "nested_expr"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "nested_expr" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '!'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '|'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(;|->|\\\\\\+|:-|=|\\\\=)(?![#$&*+\\-./:<=>?@^~\\\\])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(;|->|\\\\\\+|:-|=|\\\\=)(?![#$&*+\\-./:<=>?@^~\\\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Prolog" , "arith_expr_common" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "number"+          , Context+              { cName = "number"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "0'\\\\?$"+                              , reCompiled = Just (compileRegex True "0'\\\\?$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "syntax_error_cc" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '0' '\''+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "char_code" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '0' 'b'+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "bin" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '0' 'o'+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "oct" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '0' 'x'+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "hex" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[0-9]+\\.[0-9]+E[+\\-]?[0-9]+"+                              , reCompiled =+                                  Just (compileRegex True "[0-9]+\\.[0-9]+E[+\\-]?[0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[0-9]+\\.[0-9]+"+                              , reCompiled = Just (compileRegex True "[0-9]+\\.[0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[0-9]+E[+\\-]?[0-9]+"+                              , reCompiled = Just (compileRegex True "[0-9]+E[+\\-]?[0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "oct"+          , Context+              { cName = "oct"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = AnyChar "01234567"+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "operator"+          , Context+              { cName = "operator"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"#$%&'()*+,-./:;<=>?[\\]^`{|}~"+                              }+                            (makeWordSet True [ "is" ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "arith_expr" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"#$%&'()*+,-./:;<=>?[\\]^`{|}~"+                              }+                            (makeWordSet True [ "div" , "mod" , "rem" ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(;|->|\\\\\\+|:-|=|\\\\=)(?![#$&*+\\-./:<=>?@^~\\\\])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(;|->|\\\\\\+|:-|=|\\\\=)(?![#$&*+\\-./:<=>?@^~\\\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\?-|==|\\\\==|@=<|@<|@>=|@>|=\\.\\.|@|:)(?![#$&*+\\-./:<=>?@^~\\\\])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(\\?-|==|\\\\==|@=<|@<|@>=|@>|=\\.\\.|@|:)(?![#$&*+\\-./:<=>?@^~\\\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-->(?![#$&*+\\-./:<=>?@^~\\\\])"+                              , reCompiled =+                                  Just (compileRegex True "-->(?![#$&*+\\-./:<=>?@^~\\\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(=:=|=\\\\=|=<|<|>=|>)(?![#$&*+\\-./:<=>?@^~\\\\])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(=:=|=\\\\=|=<|<|>=|>)(?![#$&*+\\-./:<=>?@^~\\\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "arith_expr" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\+|-|\\*|\\^)(?![#$&*+\\-./:<=>?@^~\\\\])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(\\+|-|\\*|\\^)(?![#$&*+\\-./:<=>?@^~\\\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "//(?![#$&*+\\-./:<=>?@^~\\\\])"+                              , reCompiled =+                                  Just (compileRegex True "//(?![#$&*+\\-./:<=>?@^~\\\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(/|\\*\\*)(?![#$&*+\\-./:<=>?@^~\\\\])"+                              , reCompiled =+                                  Just (compileRegex True "(/|\\*\\*)(?![#$&*+\\-./:<=>?@^~\\\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(/\\\\|\\\\/|\\\\|<<|>>)(?![#$&*+\\-./:<=>?@^~\\\\])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(/\\\\|\\\\/|\\\\|<<|>>)(?![#$&*+\\-./:<=>?@^~\\\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "quoted_1st"+          , Context+              { cName = "quoted_1st"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "quoted_last"+          , Context+              { cName = "quoted_last"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "esc_seq_q" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ' '+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "region_marker"+          , Context+              { cName = "region_marker"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Prolog" , "1-comment" )+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = RegionMarkerTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "shebang"+          , Context+              { cName = "shebang"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '#' '!'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Prolog" , "1-comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "clause" ) ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Prolog" , "clause" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "single-quoted"+          , Context+              { cName = "single-quoted"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'$"+                              , reCompiled = Just (compileRegex True "'$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "sq" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "sq" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "sq"+          , Context+              { cName = "sq"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Prolog" , "quoted_1st" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(''|\\\\[0-7]+\\\\|\\\\x[a-fA-F0-9]+\\\\|\\\\.|[^'\\\\]+)$"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(''|\\\\[0-7]+\\\\|\\\\x[a-fA-F0-9]+\\\\|\\\\.|[^'\\\\]+)$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "syntax_error_sq" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\'' '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Prolog" , "quoted_last" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "syntax_error"+          , Context+              { cName = "syntax_error"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "syntax_error_bq"+          , Context+              { cName = "syntax_error_bq"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '`'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '`' '`'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Prolog" , "syntax_error" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "syntax_error_cc"+          , Context+              { cName = "syntax_error_cc"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "syntax_error_dq"+          , Context+              { cName = "syntax_error_dq"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '"'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '"' '"'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Prolog" , "syntax_error" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "syntax_error_sq"+          , Context+              { cName = "syntax_error_sq"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '\''+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\'' '\''+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Prolog" , "syntax_error" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "term"+          , Context+              { cName = "term"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Prolog" , "layout" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "list" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "curly" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '!'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '|'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '.' '('+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Prolog" , "list_functor" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.(?!(\\(|[#$&*+\\-./:<=>?@^~\\\\]))"+                              , reCompiled =+                                  Just (compileRegex True "\\.(?!(\\(|[#$&*+\\-./:<=>?@^~\\\\]))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Prolog" , "atomic" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "var"+          , Context+              { cName = "var"+              , cSyntax = "Prolog"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Torsten Eichst\228dt (torsten.eichstaedt@web.de)"+  , sVersion = "3"+  , sLicense = "LGPLv2+"+  , sExtensions = [ "*.prolog" , "*.dcg" , "*.pro" ]+  , sStartingContext = "shebang"+  }
+ src/Skylighting/Syntax/Pure.hs view
@@ -0,0 +1,407 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Pure (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Pure"+  , sFilename = "pure.xml"+  , sShortname = "Pure"+  , sContexts =+      fromList+        [ ( "Comment1"+          , Context+              { cName = "Comment1"+              , cSyntax = "Pure"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment2"+          , Context+              { cName = "Comment2"+              , cSyntax = "Pure"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Pure"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "case" , "when" , "with" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "end" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "const"+                               , "def"+                               , "else"+                               , "extern"+                               , "if"+                               , "infix"+                               , "infixl"+                               , "infixr"+                               , "interface"+                               , "let"+                               , "namespace"+                               , "nonfix"+                               , "of"+                               , "otherwise"+                               , "outfix"+                               , "postfix"+                               , "prefix"+                               , "private"+                               , "public"+                               , "then"+                               , "type"+                               , "using"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True [ "__break__" , "__trace__" , "catch" , "throw" ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "bigint"+                               , "bool"+                               , "char"+                               , "cmatrix"+                               , "dmatrix"+                               , "double"+                               , "expr"+                               , "float"+                               , "imatrix"+                               , "int"+                               , "int16"+                               , "int32"+                               , "int64"+                               , "int8"+                               , "long"+                               , "matrix"+                               , "nmatrix"+                               , "pointer"+                               , "short"+                               , "smatrix"+                               , "string"+                               , "void"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Za-z_][A-Za-z0-9_]*"+                              , reCompiled = Just (compileRegex True "[A-Za-z_][A-Za-z0-9_]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "0x[A-Za-z0-9]+"+                              , reCompiled = Just (compileRegex True "0x[A-Za-z0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCChar+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pure" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pure" , "Comment1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Pure" , "Comment2" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Region Marker"+          , Context+              { cName = "Region Marker"+              , cSyntax = "Pure"+              , cRules = []+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Pure"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = ""+  , sVersion = "1.2"+  , sLicense = ""+  , sExtensions = [ "*.pure" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Purebasic.hs view
@@ -0,0 +1,2413 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Purebasic (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "PureBasic"+  , sFilename = "purebasic.xml"+  , sShortname = "Purebasic"+  , sContexts =+      fromList+        [ ( "Comment1"+          , Context+              { cName = "Comment1"+              , cSyntax = "PureBasic"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [])+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "PureBasic"+              , cRules =+                  [ Rule+                      { rMatcher = AnyChar "-+*/%|=!<>!^&~"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar ",.:()[]\\"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(if)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(if)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(endif)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(endif)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(while)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(while)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(wend)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(wend)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(repeat)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(repeat)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(until)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(until)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(select)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(select)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(endselect)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(endselect)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(for|foreach)([\\s]|$)"+                              , reCompiled =+                                  Just (compileRegex False "\\b(for|foreach)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(next)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(next)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(procedure|proceduredll)([.\\s]|$)"+                              , reCompiled =+                                  Just (compileRegex False "\\b(procedure|proceduredll)([.\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(endprocedure)([\\s]|$)"+                              , reCompiled =+                                  Just (compileRegex False "\\b(endprocedure)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(structure)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(structure)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(endstructure)([\\s]|$)"+                              , reCompiled =+                                  Just (compileRegex False "\\b(endstructure)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(interface)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(interface)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(endinterface)([\\s]|$)"+                              , reCompiled =+                                  Just (compileRegex False "\\b(endinterface)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(enumeration)([\\s]|$)"+                              , reCompiled =+                                  Just (compileRegex False "\\b(enumeration)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(endenumeration)([\\s]|$)"+                              , reCompiled =+                                  Just (compileRegex False "\\b(endenumeration)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(datasection)([\\s]|$)"+                              , reCompiled =+                                  Just (compileRegex False "\\b(datasection)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(enddatasection)([\\s]|$)"+                              , reCompiled =+                                  Just (compileRegex False "\\b(enddatasection)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "Break"+                               , "Case"+                               , "Continue"+                               , "Data"+                               , "DataSection"+                               , "Declare"+                               , "DeclareModule"+                               , "Default"+                               , "DefType"+                               , "Dim"+                               , "Else"+                               , "ElseIf"+                               , "End"+                               , "EndDataSection"+                               , "EndDeclareModule"+                               , "EndEnumeration"+                               , "EndIf"+                               , "EndInterface"+                               , "EndModule"+                               , "EndProcedure"+                               , "EndSelect"+                               , "EndStructure"+                               , "Enumeration"+                               , "Extends"+                               , "FakeReturn"+                               , "For"+                               , "ForEach"+                               , "Global"+                               , "Gosub"+                               , "Goto"+                               , "If"+                               , "IncludeBinary"+                               , "IncludeFile"+                               , "IncludePath"+                               , "Interface"+                               , "Module"+                               , "NewList"+                               , "Next"+                               , "Procedure"+                               , "ProcedureDLL"+                               , "ProcedureReturn"+                               , "Protected"+                               , "Read"+                               , "Repeat"+                               , "Restore"+                               , "Return"+                               , "Select"+                               , "Shared"+                               , "Static"+                               , "Step"+                               , "Structure"+                               , "To"+                               , "Until"+                               , "UnuseModule"+                               , "UseModule"+                               , "Wend"+                               , "While"+                               , "With"+                               , "XIncludeFile"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(compilerif)([\\s]|$)"+                              , reCompiled = Just (compileRegex False "\\b(compilerif)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(compilerendif)([\\s]|$)"+                              , reCompiled =+                                  Just (compileRegex False "\\b(compilerendif)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(compilerselect)([\\s]|$)"+                              , reCompiled =+                                  Just (compileRegex False "\\b(compilerselect)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(compilerendselect)([\\s]|$)"+                              , reCompiled =+                                  Just (compileRegex False "\\b(compilerendselect)([\\s]|$)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "CompilerCase"+                               , "CompilerDefault"+                               , "CompilerElse"+                               , "CompilerEndIf"+                               , "CompilerEndSelect"+                               , "CompilerIf"+                               , "CompilerSelect"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "AbortFTPFile"+                               , "Abs"+                               , "ACos"+                               , "ACosH"+                               , "Add3DArchive"+                               , "AddBillboard"+                               , "AddCipherBuffer"+                               , "AddDate"+                               , "AddElement"+                               , "AddEntityAnimationTime"+                               , "AddGadgetColumn"+                               , "AddGadgetItem"+                               , "AddGadgetItem3D"+                               , "AddJSONElement"+                               , "AddJSONMember"+                               , "AddKeyboardShortcut"+                               , "AddMailAttachment"+                               , "AddMailAttachmentData"+                               , "AddMailRecipient"+                               , "AddMapElement"+                               , "AddMaterialLayer"+                               , "AddNodeAnimationTime"+                               , "AddPackFile"+                               , "AddPackMemory"+                               , "AddSplinePoint"+                               , "AddStaticGeometryEntity"+                               , "AddStatusBarField"+                               , "AddSubMesh"+                               , "AddSysTrayIcon"+                               , "AddTerrainTexture"+                               , "AddVertexPoseReference"+                               , "AddWindowTimer"+                               , "AESDecoder"+                               , "AESEncoder"+                               , "AffectedDatabaseRows"+                               , "AllocateMemory"+                               , "AllocateStructure"+                               , "Alpha"+                               , "AlphaBlend"+                               , "AmbientColor"+                               , "AntialiasingMode"+                               , "ApplyEntityForce"+                               , "ApplyEntityImpulse"+                               , "ArraySize"+                               , "Asc"+                               , "ASin"+                               , "ASinH"+                               , "ATan"+                               , "ATan2"+                               , "ATanH"+                               , "AttachEntityObject"+                               , "AttachNodeObject"+                               , "AttachRibbonEffect"+                               , "AudioCDLength"+                               , "AudioCDName"+                               , "AudioCDStatus"+                               , "AudioCDTrackLength"+                               , "AudioCDTracks"+                               , "AudioCDTrackSeconds"+                               , "AvailableProgramOutput"+                               , "AvailableScreenMemory"+                               , "AvailableSerialPortInput"+                               , "AvailableSerialPortOutput"+                               , "BackColor"+                               , "Base64Decoder"+                               , "Base64Encoder"+                               , "BillboardGroupCommonDirection"+                               , "BillboardGroupCommonUpVector"+                               , "BillboardGroupID"+                               , "BillboardGroupMaterial"+                               , "BillboardGroupX"+                               , "BillboardGroupY"+                               , "BillboardGroupZ"+                               , "BillboardHeight"+                               , "BillboardLocate"+                               , "BillboardWidth"+                               , "BillboardX"+                               , "BillboardY"+                               , "BillboardZ"+                               , "Bin"+                               , "BindEvent"+                               , "BindGadgetEvent"+                               , "BindMenuEvent"+                               , "Blue"+                               , "Box"+                               , "BoxedGradient"+                               , "BuildMeshShadowVolume"+                               , "BuildMeshTangents"+                               , "BuildStaticGeometry"+                               , "BuildTerrain"+                               , "ButtonGadget"+                               , "ButtonGadget3D"+                               , "ButtonImageGadget"+                               , "CalendarGadget"+                               , "CallCFunction"+                               , "CallCFunctionFast"+                               , "CallFunction"+                               , "CallFunctionFast"+                               , "CameraBackColor"+                               , "CameraDirection"+                               , "CameraDirectionX"+                               , "CameraDirectionY"+                               , "CameraDirectionZ"+                               , "CameraFixedYawAxis"+                               , "CameraFollow"+                               , "CameraFOV"+                               , "CameraID"+                               , "CameraLookAt"+                               , "CameraPitch"+                               , "CameraProjectionMode"+                               , "CameraProjectionX"+                               , "CameraProjectionY"+                               , "CameraRange"+                               , "CameraRenderMode"+                               , "CameraRoll"+                               , "CameraViewHeight"+                               , "CameraViewWidth"+                               , "CameraViewX"+                               , "CameraViewY"+                               , "CameraX"+                               , "CameraY"+                               , "CameraYaw"+                               , "CameraZ"+                               , "CanvasGadget"+                               , "CanvasOutput"+                               , "CatchImage"+                               , "CatchJSON"+                               , "CatchMusic"+                               , "CatchSound"+                               , "CatchSprite"+                               , "CatchXML"+                               , "ChangeCurrentElement"+                               , "ChangeGamma"+                               , "ChangeListIconGadgetDisplay"+                               , "ChangeSysTrayIcon"+                               , "CheckBoxGadget"+                               , "CheckBoxGadget3D"+                               , "CheckDatabaseNull"+                               , "CheckFilename"+                               , "CheckFTPConnection"+                               , "CheckObjectVisibility"+                               , "ChildXMLNode"+                               , "Chr"+                               , "Circle"+                               , "CircularGradient"+                               , "ClearBillboards"+                               , "ClearClipboard"+                               , "ClearConsole"+                               , "ClearDebugOutput"+                               , "ClearGadgetItemList"+                               , "ClearGadgetItems"+                               , "ClearGadgetItems3D"+                               , "ClearJSONElements"+                               , "ClearJSONMembers"+                               , "ClearList"+                               , "ClearMap"+                               , "ClearScreen"+                               , "ClearSpline"+                               , "ClipOutput"+                               , "ClipSprite"+                               , "CloseConsole"+                               , "CloseCryptRandom"+                               , "CloseDatabase"+                               , "CloseFile"+                               , "CloseFTP"+                               , "CloseGadgetList"+                               , "CloseGadgetList3D"+                               , "CloseHelp"+                               , "CloseLibrary"+                               , "CloseNetworkConnection"+                               , "CloseNetworkServer"+                               , "ClosePack"+                               , "ClosePreferences"+                               , "CloseProgram"+                               , "CloseScreen"+                               , "CloseSerialPort"+                               , "CloseSubMenu"+                               , "CloseWindow"+                               , "CloseWindow3D"+                               , "CocoaMessage"+                               , "ColorRequester"+                               , "ComboBoxGadget"+                               , "ComboBoxGadget3D"+                               , "CompareMemory"+                               , "CompareMemoryString"+                               , "ComposeJSON"+                               , "ComposeXML"+                               , "CompositorEffectParameter"+                               , "CompressMemory"+                               , "ComputerName"+                               , "ComputeSpline"+                               , "ConeTwistJoint"+                               , "ConicalGradient"+                               , "ConnectionID"+                               , "ConsoleColor"+                               , "ConsoleCursor"+                               , "ConsoleError"+                               , "ConsoleLocate"+                               , "ConsoleTitle"+                               , "ContainerGadget"+                               , "ContainerGadget3D"+                               , "ConvertLocalToWorldPosition"+                               , "ConvertWorldToLocalPosition"+                               , "CopyArray"+                               , "CopyDirectory"+                               , "CopyEntity"+                               , "CopyFile"+                               , "CopyImage"+                               , "CopyLight"+                               , "CopyList"+                               , "CopyMap"+                               , "CopyMaterial"+                               , "CopyMemory"+                               , "CopyMemoryString"+                               , "CopyMesh"+                               , "CopySprite"+                               , "CopyTexture"+                               , "CopyXMLNode"+                               , "Cos"+                               , "CosH"+                               , "CountBillboards"+                               , "CountCPUs"+                               , "CountGadgetItems"+                               , "CountGadgetItems3D"+                               , "CountLibraryFunctions"+                               , "CountList"+                               , "CountMaterialLayers"+                               , "CountProgramParameters"+                               , "CountRegularExpressionGroups"+                               , "CountSplinePoints"+                               , "CountString"+                               , "CPUName"+                               , "CRC32FileFingerprint"+                               , "CRC32Fingerprint"+                               , "CreateBillboardGroup"+                               , "CreateCamera"+                               , "CreateCompositorEffect"+                               , "CreateCube"+                               , "CreateCubeMapTexture"+                               , "CreateCylinder"+                               , "CreateDialog"+                               , "CreateDirectory"+                               , "CreateEntity"+                               , "CreateFile"+                               , "CreateFTPDirectory"+                               , "CreateGadgetList"+                               , "CreateImage"+                               , "CreateImageMenu"+                               , "CreateJSON"+                               , "CreateLensFlareEffect"+                               , "CreateLight"+                               , "CreateLine3D"+                               , "CreateMail"+                               , "CreateMaterial"+                               , "CreateMenu"+                               , "CreateMesh"+                               , "CreateMutex"+                               , "CreateNetworkServer"+                               , "CreateNode"+                               , "CreateNodeAnimation"+                               , "CreateNodeAnimationKeyFrame"+                               , "CreatePack"+                               , "CreateParticleEmitter"+                               , "CreatePlane"+                               , "CreatePopupImageMenu"+                               , "CreatePopupMenu"+                               , "CreatePreferences"+                               , "CreateRegularExpression"+                               , "CreateRenderTexture"+                               , "CreateRibbonEffect"+                               , "CreateSemaphore"+                               , "CreateSphere"+                               , "CreateSpline"+                               , "CreateSprite"+                               , "CreateStaticGeometry"+                               , "CreateStatusBar"+                               , "CreateTerrain"+                               , "CreateText3D"+                               , "CreateTexture"+                               , "CreateThread"+                               , "CreateToolBar"+                               , "CreateVertexAnimation"+                               , "CreateVertexPoseKeyFrame"+                               , "CreateVertexTrack"+                               , "CreateWater"+                               , "CreateXML"+                               , "CreateXMLNode"+                               , "CryptRandom"+                               , "CryptRandomData"+                               , "CustomFilterCallback"+                               , "CustomGradient"+                               , "DatabaseColumnIndex"+                               , "DatabaseColumnName"+                               , "DatabaseColumns"+                               , "DatabaseColumnSize"+                               , "DatabaseColumnType"+                               , "DatabaseDriverDescription"+                               , "DatabaseDriverName"+                               , "DatabaseError"+                               , "DatabaseID"+                               , "DatabaseQuery"+                               , "DatabaseUpdate"+                               , "Date"+                               , "DateGadget"+                               , "Day"+                               , "DayOfWeek"+                               , "DayOfYear"+                               , "DefaultPrinter"+                               , "DefineTerrainTile"+                               , "Degree"+                               , "Delay"+                               , "DeleteDirectory"+                               , "DeleteElement"+                               , "DeleteFile"+                               , "DeleteFTPDirectory"+                               , "DeleteFTPFile"+                               , "DeleteMapElement"+                               , "DeleteXMLNode"+                               , "DESFingerprint"+                               , "DesktopDepth"+                               , "DesktopFrequency"+                               , "DesktopHeight"+                               , "DesktopMouseX"+                               , "DesktopMouseY"+                               , "DesktopName"+                               , "DesktopWidth"+                               , "DesktopX"+                               , "DesktopY"+                               , "DetachEntityObject"+                               , "DetachNodeObject"+                               , "DetachRibbonEffect"+                               , "DialogError"+                               , "DialogGadget"+                               , "DialogID"+                               , "DialogWindow"+                               , "DirectoryEntryAttributes"+                               , "DirectoryEntryDate"+                               , "DirectoryEntryName"+                               , "DirectoryEntrySize"+                               , "DirectoryEntryType"+                               , "DisableEntityBody"+                               , "DisableGadget"+                               , "DisableGadget3D"+                               , "DisableLightShadows"+                               , "DisableMaterialLighting"+                               , "DisableMenuItem"+                               , "DisableParticleEmitter"+                               , "DisableToolBarButton"+                               , "DisableWindow"+                               , "DisableWindow3D"+                               , "DisplayPopupMenu"+                               , "DisplaySprite"+                               , "DisplayTransparentSprite"+                               , "DoubleClickTime"+                               , "DragFiles"+                               , "DragImage"+                               , "DragOSFormats"+                               , "DragPrivate"+                               , "DragText"+                               , "DrawAlphaImage"+                               , "DrawImage"+                               , "DrawingBuffer"+                               , "DrawingBufferPitch"+                               , "DrawingBufferPixelFormat"+                               , "DrawingFont"+                               , "DrawingMode"+                               , "DrawRotatedText"+                               , "DrawText"+                               , "EditorGadget"+                               , "EditorGadget3D"+                               , "EjectAudioCD"+                               , "ElapsedMilliseconds"+                               , "Ellipse"+                               , "EllipticalGradient"+                               , "EnableGadgetDrop"+                               , "EnableGraphicalConsole"+                               , "EnableHingeJointAngularMotor"+                               , "EnableManualEntityBoneControl"+                               , "EnableWindowDrop"+                               , "EnableWorldCollisions"+                               , "EnableWorldPhysics"+                               , "EncodeImage"+                               , "Engine3DStatus"+                               , "EntityAngularFactor"+                               , "EntityAnimationBlendMode"+                               , "EntityAnimationStatus"+                               , "EntityBonePitch"+                               , "EntityBoneRoll"+                               , "EntityBoneX"+                               , "EntityBoneY"+                               , "EntityBoneYaw"+                               , "EntityBoneZ"+                               , "EntityBoundingBox"+                               , "EntityCollide"+                               , "EntityCubeMapTexture"+                               , "EntityCustomParameter"+                               , "EntityFixedYawAxis"+                               , "EntityID"+                               , "EntityLinearFactor"+                               , "EntityLookAt"+                               , "EntityParentNode"+                               , "EntityPhysicBody"+                               , "EntityPitch"+                               , "EntityRenderMode"+                               , "EntityRoll"+                               , "EntityVelocity"+                               , "EntityX"+                               , "EntityY"+                               , "EntityYaw"+                               , "EntityZ"+                               , "EnvironmentVariableName"+                               , "EnvironmentVariableValue"+                               , "Eof"+                               , "ErrorAddress"+                               , "ErrorCode"+                               , "ErrorFile"+                               , "ErrorLine"+                               , "ErrorMessage"+                               , "ErrorRegister"+                               , "ErrorTargetAddress"+                               , "EventClient"+                               , "EventData"+                               , "EventDropAction"+                               , "EventDropBuffer"+                               , "EventDropFiles"+                               , "EventDropImage"+                               , "EventDropPrivate"+                               , "EventDropSize"+                               , "EventDropText"+                               , "EventDropType"+                               , "EventDropX"+                               , "EventDropY"+                               , "EventGadget"+                               , "EventGadget3D"+                               , "EventlParam"+                               , "EventMenu"+                               , "EventServer"+                               , "EventTimer"+                               , "EventType"+                               , "EventType3D"+                               , "EventWindow"+                               , "EventWindow3D"+                               , "EventwParam"+                               , "ExamineAssembly"+                               , "ExamineDatabaseDrivers"+                               , "ExamineDesktops"+                               , "ExamineDirectory"+                               , "ExamineEnvironmentVariables"+                               , "ExamineFTPDirectory"+                               , "ExamineIPAddresses"+                               , "ExamineJoystick"+                               , "ExamineJSONMembers"+                               , "ExamineKeyboard"+                               , "ExamineLibraryFunctions"+                               , "ExamineMD5Fingerprint"+                               , "ExamineMouse"+                               , "ExaminePack"+                               , "ExaminePreferenceGroups"+                               , "ExaminePreferenceKeys"+                               , "ExamineRegularExpression"+                               , "ExamineScreenModes"+                               , "ExamineSHA1Fingerprint"+                               , "ExamineWorldCollisions"+                               , "ExamineXMLAttributes"+                               , "Exp"+                               , "ExplorerComboGadget"+                               , "ExplorerListGadget"+                               , "ExplorerTreeGadget"+                               , "ExportJSON"+                               , "ExportJSONSize"+                               , "ExportXML"+                               , "ExportXMLSize"+                               , "ExtractJSONArray"+                               , "ExtractJSONList"+                               , "ExtractJSONMap"+                               , "ExtractJSONStructure"+                               , "ExtractRegularExpression"+                               , "ExtractXMLArray"+                               , "ExtractXMLList"+                               , "ExtractXMLMap"+                               , "ExtractXMLStructure"+                               , "FetchEntityMaterial"+                               , "FetchOrientation"+                               , "FileBuffersSize"+                               , "FileID"+                               , "FileSeek"+                               , "FileSize"+                               , "FillArea"+                               , "FillMemory"+                               , "FindMapElement"+                               , "FindString"+                               , "FinishCipher"+                               , "FinishDatabaseQuery"+                               , "FinishDirectory"+                               , "FinishFingerprint"+                               , "FinishFTPDirectory"+                               , "FinishMesh"+                               , "FirstDatabaseRow"+                               , "FirstElement"+                               , "FirstWorldCollisionEntity"+                               , "FlipBuffers"+                               , "FlushFileBuffers"+                               , "Fog"+                               , "FontID"+                               , "FontRequester"+                               , "FormatDate"+                               , "FormatXML"+                               , "FrameGadget"+                               , "FrameGadget3D"+                               , "FreeArray"+                               , "FreeBillboardGroup"+                               , "FreeCamera"+                               , "FreeDialog"+                               , "FreeEffect"+                               , "FreeEntity"+                               , "FreeEntityJoints"+                               , "FreeFont"+                               , "FreeGadget"+                               , "FreeGadget3D"+                               , "FreeImage"+                               , "FreeIP"+                               , "FreeJoint"+                               , "FreeJSON"+                               , "FreeLight"+                               , "FreeList"+                               , "FreeMail"+                               , "FreeMap"+                               , "FreeMaterial"+                               , "FreeMemory"+                               , "FreeMenu"+                               , "FreeMesh"+                               , "FreeMovie"+                               , "FreeMusic"+                               , "FreeMutex"+                               , "FreeNode"+                               , "FreeNodeAnimation"+                               , "FreeParticleEmitter"+                               , "FreeRegularExpression"+                               , "FreeSemaphore"+                               , "FreeSound"+                               , "FreeSound3D"+                               , "FreeSpline"+                               , "FreeSprite"+                               , "FreeStaticGeometry"+                               , "FreeStatusBar"+                               , "FreeStructure"+                               , "FreeTerrain"+                               , "FreeText3D"+                               , "FreeTexture"+                               , "FreeToolBar"+                               , "FreeWater"+                               , "FreeXML"+                               , "FrontColor"+                               , "FTPDirectoryEntryAttributes"+                               , "FTPDirectoryEntryDate"+                               , "FTPDirectoryEntryName"+                               , "FTPDirectoryEntryRaw"+                               , "FTPDirectoryEntrySize"+                               , "FTPDirectoryEntryType"+                               , "FTPProgress"+                               , "GadgetHeight"+                               , "GadgetHeight3D"+                               , "GadgetID"+                               , "GadgetID3D"+                               , "GadgetItemID"+                               , "GadgetToolTip"+                               , "GadgetToolTip3D"+                               , "GadgetType"+                               , "GadgetType3D"+                               , "GadgetWidth"+                               , "GadgetWidth3D"+                               , "GadgetX"+                               , "GadgetX3D"+                               , "GadgetY"+                               , "GadgetY3D"+                               , "GetActiveGadget"+                               , "GetActiveGadget3D"+                               , "GetActiveWindow"+                               , "GetActiveWindow3D"+                               , "GetClientIP"+                               , "GetClientPort"+                               , "GetClipboardImage"+                               , "GetClipboardText"+                               , "GetCurrentDirectory"+                               , "GetDatabaseBlob"+                               , "GetDatabaseDouble"+                               , "GetDatabaseFloat"+                               , "GetDatabaseLong"+                               , "GetDatabaseQuad"+                               , "GetDatabaseString"+                               , "GetEntityAnimationLength"+                               , "GetEntityAnimationTime"+                               , "GetEntityAnimationWeight"+                               , "GetEntityAttribute"+                               , "GetEntityCollisionGroup"+                               , "GetEntityCollisionMask"+                               , "GetEnvironmentVariable"+                               , "GetExtensionPart"+                               , "GetFileAttributes"+                               , "GetFileDate"+                               , "GetFilePart"+                               , "GetFTPDirectory"+                               , "GetFunction"+                               , "GetFunctionEntry"+                               , "GetGadgetAttribute"+                               , "GetGadgetAttribute3D"+                               , "GetGadgetColor"+                               , "GetGadgetData"+                               , "GetGadgetData3D"+                               , "GetGadgetFont"+                               , "GetGadgetItemAttribute"+                               , "GetGadgetItemColor"+                               , "GetGadgetItemData"+                               , "GetGadgetItemData3D"+                               , "GetGadgetItemState"+                               , "GetGadgetItemState3D"+                               , "GetGadgetItemText"+                               , "GetGadgetItemText3D"+                               , "GetGadgetState"+                               , "GetGadgetState3D"+                               , "GetGadgetText"+                               , "GetGadgetText3D"+                               , "GetHomeDirectory"+                               , "GetHTTPHeader"+                               , "GetJointAttribute"+                               , "GetJSONBoolean"+                               , "GetJSONDouble"+                               , "GetJSONElement"+                               , "GetJSONFloat"+                               , "GetJSONInteger"+                               , "GetJSONMember"+                               , "GetJSONQuad"+                               , "GetJSONString"+                               , "GetLightColor"+                               , "GetMailAttribute"+                               , "GetMailBody"+                               , "GetMaterialAttribute"+                               , "GetMaterialColor"+                               , "GetMenuItemState"+                               , "GetMenuItemText"+                               , "GetMenuTitleText"+                               , "GetMeshData"+                               , "GetMusicPosition"+                               , "GetMusicRow"+                               , "GetNodeAnimationKeyFrameTime"+                               , "GetNodeAnimationLength"+                               , "GetNodeAnimationTime"+                               , "GetNodeAnimationWeight"+                               , "GetOriginX"+                               , "GetOriginY"+                               , "GetPathPart"+                               , "GetRuntimeDouble"+                               , "GetRuntimeInteger"+                               , "GetRuntimeString"+                               , "GetScriptMaterial"+                               , "GetScriptParticleEmitter"+                               , "GetScriptTexture"+                               , "GetSerialPortStatus"+                               , "GetSoundFrequency"+                               , "GetSoundPosition"+                               , "GetTemporaryDirectory"+                               , "GetTerrainTileHeightAtPoint"+                               , "GetTerrainTileLayerBlend"+                               , "GetToolBarButtonState"+                               , "GetURLPart"+                               , "GetW"+                               , "GetWindowColor"+                               , "GetWindowData"+                               , "GetWindowState"+                               , "GetWindowTitle"+                               , "GetWindowTitle3D"+                               , "GetX"+                               , "GetXMLAttribute"+                               , "GetXMLEncoding"+                               , "GetXMLNodeName"+                               , "GetXMLNodeOffset"+                               , "GetXMLNodeText"+                               , "GetXMLStandalone"+                               , "GetY"+                               , "GetZ"+                               , "GrabDrawingImage"+                               , "GrabImage"+                               , "GrabSprite"+                               , "GradientColor"+                               , "Green"+                               , "Hex"+                               , "HideBillboardGroup"+                               , "HideEffect"+                               , "HideEntity"+                               , "HideGadget"+                               , "HideGadget3D"+                               , "HideLight"+                               , "HideMenu"+                               , "HideParticleEmitter"+                               , "HideWindow"+                               , "HideWindow3D"+                               , "HingeJoint"+                               , "HingeJointMotorTarget"+                               , "HostName"+                               , "Hour"+                               , "HyperLinkGadget"+                               , "ImageDepth"+                               , "ImageFormat"+                               , "ImageGadget"+                               , "ImageGadget3D"+                               , "ImageHeight"+                               , "ImageID"+                               , "ImageOutput"+                               , "ImageWidth"+                               , "Infinity"+                               , "InitAudioCD"+                               , "InitEngine3D"+                               , "InitJoystick"+                               , "InitKeyboard"+                               , "InitMouse"+                               , "InitMovie"+                               , "InitNetwork"+                               , "InitScintilla"+                               , "InitSound"+                               , "InitSprite"+                               , "Inkey"+                               , "Input"+                               , "InputEvent3D"+                               , "InputRequester"+                               , "InsertElement"+                               , "InsertJSONArray"+                               , "InsertJSONList"+                               , "InsertJSONMap"+                               , "InsertJSONStructure"+                               , "InsertString"+                               , "InsertXMLArray"+                               , "InsertXMLList"+                               , "InsertXMLMap"+                               , "InsertXMLStructure"+                               , "InstructionAddress"+                               , "InstructionString"+                               , "Int"+                               , "IntQ"+                               , "IPAddressField"+                               , "IPAddressGadget"+                               , "IPString"+                               , "IsBillboardGroup"+                               , "IsCamera"+                               , "IsDatabase"+                               , "IsDialog"+                               , "IsDirectory"+                               , "IsEffect"+                               , "IsEntity"+                               , "IsFile"+                               , "IsFingerprint"+                               , "IsFont"+                               , "IsFtp"+                               , "IsGadget"+                               , "IsGadget3D"+                               , "IsImage"+                               , "IsInfinity"+                               , "IsJSON"+                               , "IsLibrary"+                               , "IsLight"+                               , "IsMail"+                               , "IsMaterial"+                               , "IsMenu"+                               , "IsMesh"+                               , "IsMovie"+                               , "IsMusic"+                               , "IsNaN"+                               , "IsNode"+                               , "IsParticleEmitter"+                               , "IsProgram"+                               , "IsRegularExpression"+                               , "IsRuntime"+                               , "IsScreenActive"+                               , "IsSerialPort"+                               , "IsSound"+                               , "IsSound3D"+                               , "IsSprite"+                               , "IsStaticGeometry"+                               , "IsStatusBar"+                               , "IsSysTrayIcon"+                               , "IsText3D"+                               , "IsTexture"+                               , "IsThread"+                               , "IsToolBar"+                               , "IsWindow"+                               , "IsWindow3D"+                               , "IsXML"+                               , "JoystickAxisX"+                               , "JoystickAxisY"+                               , "JoystickAxisZ"+                               , "JoystickButton"+                               , "JoystickName"+                               , "JSONArraySize"+                               , "JSONErrorLine"+                               , "JSONErrorMessage"+                               , "JSONErrorPosition"+                               , "JSONMemberKey"+                               , "JSONMemberValue"+                               , "JSONObjectSize"+                               , "JSONType"+                               , "JSONValue"+                               , "KeyboardInkey"+                               , "KeyboardMode"+                               , "KeyboardPushed"+                               , "KeyboardReleased"+                               , "KillProgram"+                               , "KillThread"+                               , "LastElement"+                               , "LCase"+                               , "Left"+                               , "Len"+                               , "LensFlareEffectColor"+                               , "LibraryFunctionAddress"+                               , "LibraryFunctionName"+                               , "LibraryID"+                               , "LightAttenuation"+                               , "LightDirection"+                               , "LightDirectionX"+                               , "LightDirectionY"+                               , "LightDirectionZ"+                               , "LightID"+                               , "LightLookAt"+                               , "LightPitch"+                               , "LightRoll"+                               , "LightX"+                               , "LightY"+                               , "LightYaw"+                               , "LightZ"+                               , "Line"+                               , "LinearGradient"+                               , "LineXY"+                               , "ListIconGadget"+                               , "ListIndex"+                               , "ListSize"+                               , "ListViewGadget"+                               , "ListViewGadget3D"+                               , "LoadFont"+                               , "LoadImage"+                               , "LoadJSON"+                               , "LoadMesh"+                               , "LoadMovie"+                               , "LoadMusic"+                               , "LoadSound"+                               , "LoadSound3D"+                               , "LoadSprite"+                               , "LoadTexture"+                               , "LoadWorld"+                               , "LoadXML"+                               , "Loc"+                               , "LockMutex"+                               , "Lof"+                               , "Log"+                               , "Log10"+                               , "LSet"+                               , "LTrim"+                               , "MailProgress"+                               , "MainXMLNode"+                               , "MakeIPAddress"+                               , "MapKey"+                               , "MapSize"+                               , "MatchRegularExpression"+                               , "MaterialBlendingMode"+                               , "MaterialCullingMode"+                               , "MaterialFilteringMode"+                               , "MaterialFog"+                               , "MaterialID"+                               , "MaterialShadingMode"+                               , "MaterialShininess"+                               , "MD5FileFingerprint"+                               , "MD5Fingerprint"+                               , "MDIGadget"+                               , "MemorySize"+                               , "MemoryStatus"+                               , "MemoryStringLength"+                               , "MenuBar"+                               , "MenuHeight"+                               , "MenuID"+                               , "MenuItem"+                               , "MenuTitle"+                               , "MergeLists"+                               , "MeshFace"+                               , "MeshID"+                               , "MeshIndex"+                               , "MeshIndexCount"+                               , "MeshPoseCount"+                               , "MeshPoseName"+                               , "MeshRadius"+                               , "MeshVertexColor"+                               , "MeshVertexCount"+                               , "MeshVertexNormal"+                               , "MeshVertexPosition"+                               , "MeshVertexTangent"+                               , "MeshVertexTextureCoordinate"+                               , "MessageRequester"+                               , "Mid"+                               , "Minute"+                               , "Mod"+                               , "Month"+                               , "MouseButton"+                               , "MouseDeltaX"+                               , "MouseDeltaY"+                               , "MouseLocate"+                               , "MousePick"+                               , "MouseRayCast"+                               , "MouseWheel"+                               , "MouseX"+                               , "MouseY"+                               , "MoveBillboard"+                               , "MoveBillboardGroup"+                               , "MoveCamera"+                               , "MoveElement"+                               , "MoveEntity"+                               , "MoveEntityBone"+                               , "MoveLight"+                               , "MoveMemory"+                               , "MoveNode"+                               , "MoveParticleEmitter"+                               , "MoveText3D"+                               , "MoveXMLNode"+                               , "MovieAudio"+                               , "MovieHeight"+                               , "MovieInfo"+                               , "MovieLength"+                               , "MovieSeek"+                               , "MovieStatus"+                               , "MovieWidth"+                               , "MusicVolume"+                               , "NaN"+                               , "NetworkClientEvent"+                               , "NetworkServerEvent"+                               , "NewPrinterPage"+                               , "NextDatabaseDriver"+                               , "NextDatabaseRow"+                               , "NextDirectoryEntry"+                               , "NextElement"+                               , "NextEnvironmentVariable"+                               , "NextFingerprint"+                               , "NextFTPDirectoryEntry"+                               , "NextInstruction"+                               , "NextIPAddress"+                               , "NextJSONMember"+                               , "NextLibraryFunction"+                               , "NextMapElement"+                               , "NextPackEntry"+                               , "NextPreferenceGroup"+                               , "NextPreferenceKey"+                               , "NextRegularExpressionMatch"+                               , "NextScreenMode"+                               , "NextSelectedFilename"+                               , "NextWorldCollision"+                               , "NextXMLAttribute"+                               , "NextXMLNode"+                               , "NodeAnimationKeyFramePitch"+                               , "NodeAnimationKeyFrameRoll"+                               , "NodeAnimationKeyFrameX"+                               , "NodeAnimationKeyFrameY"+                               , "NodeAnimationKeyFrameYaw"+                               , "NodeAnimationKeyFrameZ"+                               , "NodeAnimationStatus"+                               , "NodeFixedYawAxis"+                               , "NodeID"+                               , "NodeLookAt"+                               , "NodePitch"+                               , "NodeRoll"+                               , "NodeX"+                               , "NodeY"+                               , "NodeYaw"+                               , "NodeZ"+                               , "NormalizeMesh"+                               , "NormalX"+                               , "NormalY"+                               , "NormalZ"+                               , "OnErrorCall"+                               , "OnErrorDefault"+                               , "OnErrorExit"+                               , "OnErrorGoto"+                               , "OpenConsole"+                               , "OpenCryptRandom"+                               , "OpenDatabase"+                               , "OpenDatabaseRequester"+                               , "OpenFile"+                               , "OpenFileRequester"+                               , "OpenFTP"+                               , "OpenGadgetList"+                               , "OpenGadgetList3D"+                               , "OpenGLGadget"+                               , "OpenHelp"+                               , "OpenLibrary"+                               , "OpenNetworkConnection"+                               , "OpenPack"+                               , "OpenPreferences"+                               , "OpenScreen"+                               , "OpenSerialPort"+                               , "OpenSubMenu"+                               , "OpenWindow"+                               , "OpenWindow3D"+                               , "OpenWindowedScreen"+                               , "OpenXMLDialog"+                               , "OptionGadget"+                               , "OptionGadget3D"+                               , "OSVersion"+                               , "OutputDepth"+                               , "OutputHeight"+                               , "OutputWidth"+                               , "PackEntryName"+                               , "PackEntrySize"+                               , "PackEntryType"+                               , "PanelGadget"+                               , "PanelGadget3D"+                               , "ParentXMLNode"+                               , "Parse3DScripts"+                               , "ParseDate"+                               , "ParseJSON"+                               , "ParseXML"+                               , "ParticleColorFader"+                               , "ParticleColorRange"+                               , "ParticleEmissionRate"+                               , "ParticleEmitterDirection"+                               , "ParticleEmitterID"+                               , "ParticleEmitterX"+                               , "ParticleEmitterY"+                               , "ParticleEmitterZ"+                               , "ParticleMaterial"+                               , "ParticleSize"+                               , "ParticleSpeedFactor"+                               , "ParticleTimeToLive"+                               , "ParticleVelocity"+                               , "PathRequester"+                               , "PauseAudioCD"+                               , "PauseMovie"+                               , "PauseSound"+                               , "PauseThread"+                               , "PeekA"+                               , "PeekB"+                               , "PeekC"+                               , "PeekD"+                               , "PeekF"+                               , "PeekI"+                               , "PeekL"+                               , "PeekQ"+                               , "PeekS"+                               , "PeekU"+                               , "PeekW"+                               , "PickX"+                               , "PickY"+                               , "PickZ"+                               , "Pitch"+                               , "PlayAudioCD"+                               , "PlayMovie"+                               , "PlayMusic"+                               , "PlaySound"+                               , "PlaySound3D"+                               , "Plot"+                               , "Point"+                               , "PointJoint"+                               , "PointPick"+                               , "PokeA"+                               , "PokeB"+                               , "PokeC"+                               , "PokeD"+                               , "PokeF"+                               , "PokeI"+                               , "PokeL"+                               , "PokeQ"+                               , "PokeS"+                               , "PokeU"+                               , "PokeW"+                               , "PopListPosition"+                               , "PopMapPosition"+                               , "PostEvent"+                               , "Pow"+                               , "PreferenceComment"+                               , "PreferenceGroup"+                               , "PreferenceGroupName"+                               , "PreferenceKeyName"+                               , "PreferenceKeyValue"+                               , "PreviousDatabaseRow"+                               , "PreviousElement"+                               , "PreviousXMLNode"+                               , "Print"+                               , "PrinterOutput"+                               , "PrinterPageHeight"+                               , "PrinterPageWidth"+                               , "PrintN"+                               , "PrintRequester"+                               , "ProgramExitCode"+                               , "ProgramFilename"+                               , "ProgramID"+                               , "ProgramParameter"+                               , "ProgramRunning"+                               , "ProgressBarGadget"+                               , "ProgressBarGadget3D"+                               , "PurifierGranularity"+                               , "PushListPosition"+                               , "PushMapPosition"+                               , "Radian"+                               , "RaiseError"+                               , "Random"+                               , "RandomData"+                               , "RandomizeArray"+                               , "RandomizeList"+                               , "RandomSeed"+                               , "RawKey"+                               , "RayCast"+                               , "RayCollide"+                               , "RayPick"+                               , "ReadAsciiCharacter"+                               , "ReadByte"+                               , "ReadCharacter"+                               , "ReadConsoleData"+                               , "ReadData"+                               , "ReadDouble"+                               , "ReadFile"+                               , "ReadFloat"+                               , "ReadInteger"+                               , "ReadLong"+                               , "ReadPreferenceDouble"+                               , "ReadPreferenceFloat"+                               , "ReadPreferenceInteger"+                               , "ReadPreferenceLong"+                               , "ReadPreferenceQuad"+                               , "ReadPreferenceString"+                               , "ReadProgramData"+                               , "ReadProgramError"+                               , "ReadProgramString"+                               , "ReadQuad"+                               , "ReadSerialPortData"+                               , "ReadString"+                               , "ReadStringFormat"+                               , "ReadUnicodeCharacter"+                               , "ReadWord"+                               , "ReAllocateMemory"+                               , "ReceiveFTPFile"+                               , "ReceiveHTTPFile"+                               , "ReceiveNetworkData"+                               , "Red"+                               , "RegularExpressionError"+                               , "RegularExpressionGroup"+                               , "RegularExpressionGroupLength"+                               , "RegularExpressionGroupPosition"+                               , "RegularExpressionMatchLength"+                               , "RegularExpressionMatchPosition"+                               , "RegularExpressionMatchString"+                               , "RegularExpressionNamedGroup"+                               , "RegularExpressionNamedGroupLength"+                               , "RegularExpressionNamedGroupPosition"+                               , "ReleaseMouse"+                               , "ReloadMaterial"+                               , "RemoveBillboard"+                               , "RemoveEnvironmentVariable"+                               , "RemoveGadgetColumn"+                               , "RemoveGadgetItem"+                               , "RemoveGadgetItem3D"+                               , "RemoveJSONElement"+                               , "RemoveJSONMember"+                               , "RemoveKeyboardShortcut"+                               , "RemoveMailRecipient"+                               , "RemoveMaterialLayer"+                               , "RemovePackFile"+                               , "RemovePreferenceGroup"+                               , "RemovePreferenceKey"+                               , "RemoveString"+                               , "RemoveSysTrayIcon"+                               , "RemoveWindowTimer"+                               , "RemoveXMLAttribute"+                               , "RenameFile"+                               , "RenameFTPFile"+                               , "RenderWorld"+                               , "ReplaceRegularExpression"+                               , "ReplaceString"+                               , "ResetGradientColors"+                               , "ResetList"+                               , "ResetMap"+                               , "ResetMaterial"+                               , "ResetProfiler"+                               , "ResizeBillboard"+                               , "ResizeGadget"+                               , "ResizeGadget3D"+                               , "ResizeImage"+                               , "ResizeJSONElements"+                               , "ResizeMovie"+                               , "ResizeParticleEmitter"+                               , "ResizeWindow"+                               , "ResizeWindow3D"+                               , "ResolveXMLAttributeName"+                               , "ResolveXMLNodeName"+                               , "ResumeAudioCD"+                               , "ResumeMovie"+                               , "ResumeSound"+                               , "ResumeThread"+                               , "ReverseString"+                               , "RGB"+                               , "RGBA"+                               , "RibbonEffectColor"+                               , "RibbonEffectWidth"+                               , "Right"+                               , "Roll"+                               , "RootXMLNode"+                               , "RotateBillboardGroup"+                               , "RotateCamera"+                               , "RotateEntity"+                               , "RotateEntityBone"+                               , "RotateLight"+                               , "RotateMaterial"+                               , "RotateNode"+                               , "RotateSprite"+                               , "Round"+                               , "RoundBox"+                               , "RSet"+                               , "RTrim"+                               , "RunProgram"+                               , "SaveDebugOutput"+                               , "SaveFileRequester"+                               , "SaveImage"+                               , "SaveJSON"+                               , "SaveMesh"+                               , "SaveRenderTexture"+                               , "SaveSprite"+                               , "SaveTerrain"+                               , "SaveXML"+                               , "ScaleEntity"+                               , "ScaleMaterial"+                               , "ScaleNode"+                               , "ScaleText3D"+                               , "ScintillaGadget"+                               , "ScintillaSendMessage"+                               , "ScreenDepth"+                               , "ScreenHeight"+                               , "ScreenID"+                               , "ScreenModeDepth"+                               , "ScreenModeHeight"+                               , "ScreenModeRefreshRate"+                               , "ScreenModeWidth"+                               , "ScreenOutput"+                               , "ScreenWidth"+                               , "ScrollAreaGadget"+                               , "ScrollAreaGadget3D"+                               , "ScrollBarGadget"+                               , "ScrollBarGadget3D"+                               , "ScrollMaterial"+                               , "Second"+                               , "SecondWorldCollisionEntity"+                               , "SelectedFilePattern"+                               , "SelectedFontColor"+                               , "SelectedFontName"+                               , "SelectedFontSize"+                               , "SelectedFontStyle"+                               , "SelectElement"+                               , "SendFTPFile"+                               , "SendMail"+                               , "SendNetworkData"+                               , "SendNetworkString"+                               , "SerialPortError"+                               , "SerialPortID"+                               , "SerialPortTimeouts"+                               , "ServerID"+                               , "SetActiveGadget"+                               , "SetActiveGadget3D"+                               , "SetActiveWindow"+                               , "SetActiveWindow3D"+                               , "SetClipboardImage"+                               , "SetClipboardText"+                               , "SetCurrentDirectory"+                               , "SetDatabaseBlob"+                               , "SetDragCallback"+                               , "SetDropCallback"+                               , "SetEntityAnimationLength"+                               , "SetEntityAnimationTime"+                               , "SetEntityAnimationWeight"+                               , "SetEntityAttribute"+                               , "SetEntityCollisionFilter"+                               , "SetEntityMaterial"+                               , "SetEnvironmentVariable"+                               , "SetFileAttributes"+                               , "SetFileDate"+                               , "SetFrameRate"+                               , "SetFTPDirectory"+                               , "SetGadgetAttribute"+                               , "SetGadgetAttribute3D"+                               , "SetGadgetColor"+                               , "SetGadgetData"+                               , "SetGadgetData3D"+                               , "SetGadgetFont"+                               , "SetGadgetItemAttribute"+                               , "SetGadgetItemColor"+                               , "SetGadgetItemData"+                               , "SetGadgetItemData3D"+                               , "SetGadgetItemImage"+                               , "SetGadgetItemState"+                               , "SetGadgetItemState3D"+                               , "SetGadgetItemText"+                               , "SetGadgetItemText3D"+                               , "SetGadgetState"+                               , "SetGadgetState3D"+                               , "SetGadgetText"+                               , "SetGadgetText3D"+                               , "SetGUITheme3D"+                               , "SetJointAttribute"+                               , "SetJSONArray"+                               , "SetJSONBoolean"+                               , "SetJSONDouble"+                               , "SetJSONFloat"+                               , "SetJSONInteger"+                               , "SetJSONNull"+                               , "SetJSONObject"+                               , "SetJSONQuad"+                               , "SetJSONString"+                               , "SetLightColor"+                               , "SetMailAttribute"+                               , "SetMailBody"+                               , "SetMaterialAttribute"+                               , "SetMaterialColor"+                               , "SetMenuItemState"+                               , "SetMenuItemText"+                               , "SetMenuTitleText"+                               , "SetMeshData"+                               , "SetMeshMaterial"+                               , "SetMusicPosition"+                               , "SetNodeAnimationKeyFramePosition"+                               , "SetNodeAnimationKeyFrameRotation"+                               , "SetNodeAnimationKeyFrameScale"+                               , "SetNodeAnimationLength"+                               , "SetNodeAnimationTime"+                               , "SetNodeAnimationWeight"+                               , "SetOrientation"+                               , "SetOrigin"+                               , "SetRenderQueue"+                               , "SetRuntimeDouble"+                               , "SetRuntimeInteger"+                               , "SetRuntimeString"+                               , "SetSerialPortStatus"+                               , "SetSoundFrequency"+                               , "SetSoundPosition"+                               , "SetTerrainTileHeightAtPoint"+                               , "SetTerrainTileLayerBlend"+                               , "SetToolBarButtonState"+                               , "SetupTerrains"+                               , "SetURLPart"+                               , "SetWindowCallback"+                               , "SetWindowColor"+                               , "SetWindowData"+                               , "SetWindowState"+                               , "SetWindowTitle"+                               , "SetWindowTitle3D"+                               , "SetXMLAttribute"+                               , "SetXMLEncoding"+                               , "SetXMLNodeName"+                               , "SetXMLNodeOffset"+                               , "SetXMLNodeText"+                               , "SetXMLStandalone"+                               , "SHA1FileFingerprint"+                               , "SHA1Fingerprint"+                               , "ShortcutGadget"+                               , "ShowAssemblyViewer"+                               , "ShowCallstack"+                               , "ShowDebugOutput"+                               , "ShowGUI"+                               , "ShowLibraryViewer"+                               , "ShowMemoryViewer"+                               , "ShowProfiler"+                               , "ShowVariableViewer"+                               , "ShowWatchlist"+                               , "Sign"+                               , "SignalSemaphore"+                               , "Sin"+                               , "SinH"+                               , "SkyBox"+                               , "SkyDome"+                               , "SliderJoint"+                               , "SmartWindowRefresh"+                               , "SortArray"+                               , "SortList"+                               , "SortStructuredArray"+                               , "SortStructuredList"+                               , "SoundCone3D"+                               , "SoundID3D"+                               , "SoundLength"+                               , "SoundListenerLocate"+                               , "SoundPan"+                               , "SoundRange3D"+                               , "SoundStatus"+                               , "SoundVolume"+                               , "SoundVolume3D"+                               , "Space"+                               , "SpinGadget"+                               , "SpinGadget3D"+                               , "SplinePointX"+                               , "SplinePointY"+                               , "SplinePointZ"+                               , "SplineX"+                               , "SplineY"+                               , "SplineZ"+                               , "SplitList"+                               , "SplitterGadget"+                               , "SpotLightRange"+                               , "SpriteBlendingMode"+                               , "SpriteCollision"+                               , "SpriteDepth"+                               , "SpriteHeight"+                               , "SpriteID"+                               , "SpriteOutput"+                               , "SpritePixelCollision"+                               , "SpriteQuality"+                               , "SpriteWidth"+                               , "Sqr"+                               , "StartAESCipher"+                               , "StartDrawing"+                               , "StartEntityAnimation"+                               , "StartNodeAnimation"+                               , "StartPrinting"+                               , "StartProfiler"+                               , "StatusBarHeight"+                               , "StatusBarID"+                               , "StatusBarImage"+                               , "StatusBarProgress"+                               , "StatusBarText"+                               , "StickyWindow"+                               , "StopAudioCD"+                               , "StopDrawing"+                               , "StopEntityAnimation"+                               , "StopMovie"+                               , "StopMusic"+                               , "StopNodeAnimation"+                               , "StopPrinting"+                               , "StopProfiler"+                               , "StopSound"+                               , "StopSound3D"+                               , "Str"+                               , "StrD"+                               , "StrF"+                               , "StringByteLength"+                               , "StringField"+                               , "StringGadget"+                               , "StringGadget3D"+                               , "StrU"+                               , "SubMeshCount"+                               , "Sun"+                               , "SwapElements"+                               , "SwitchCamera"+                               , "SysTrayIconToolTip"+                               , "Tan"+                               , "TanH"+                               , "TerrainHeight"+                               , "TerrainLocate"+                               , "TerrainMousePick"+                               , "TerrainPhysicBody"+                               , "TerrainRenderMode"+                               , "TerrainTileHeightAtPosition"+                               , "TerrainTileLayerMapSize"+                               , "TerrainTilePointX"+                               , "TerrainTilePointY"+                               , "TerrainTileSize"+                               , "Text3DAlignment"+                               , "Text3DCaption"+                               , "Text3DColor"+                               , "Text3DID"+                               , "TextGadget"+                               , "TextGadget3D"+                               , "TextHeight"+                               , "TextureHeight"+                               , "TextureID"+                               , "TextureOutput"+                               , "TextureWidth"+                               , "TextWidth"+                               , "ThreadID"+                               , "ThreadPriority"+                               , "ToolBarHeight"+                               , "ToolBarID"+                               , "ToolBarImageButton"+                               , "ToolBarSeparator"+                               , "ToolBarStandardButton"+                               , "ToolBarToolTip"+                               , "TrackBarGadget"+                               , "TransformMesh"+                               , "TransformSprite"+                               , "TransparentSpriteColor"+                               , "TreeGadget"+                               , "Trim"+                               , "TruncateFile"+                               , "TryLockMutex"+                               , "TrySemaphore"+                               , "UCase"+                               , "UnbindEvent"+                               , "UnbindGadgetEvent"+                               , "UnbindMenuEvent"+                               , "UnclipOutput"+                               , "UncompressMemory"+                               , "UncompressPackFile"+                               , "UncompressPackMemory"+                               , "UnlockMutex"+                               , "UpdateEntityAnimation"+                               , "UpdateMesh"+                               , "UpdateMeshBoundingBox"+                               , "UpdateRenderTexture"+                               , "UpdateSplinePoint"+                               , "UpdateTerrain"+                               , "UpdateTerrainTileLayerBlend"+                               , "UpdateVertexPoseReference"+                               , "URLDecoder"+                               , "URLEncoder"+                               , "UseAudioCD"+                               , "UseBriefLZPacker"+                               , "UseFLACSoundDecoder"+                               , "UseGadgetList"+                               , "UseJCALG1Packer"+                               , "UseJPEG2000ImageDecoder"+                               , "UseJPEG2000ImageEncoder"+                               , "UseJPEGImageDecoder"+                               , "UseJPEGImageEncoder"+                               , "UseLZMAPacker"+                               , "UseODBCDatabase"+                               , "UseOGGSoundDecoder"+                               , "UsePNGImageDecoder"+                               , "UsePNGImageEncoder"+                               , "UsePostgreSQLDatabase"+                               , "UserName"+                               , "UseSQLiteDatabase"+                               , "UseTGAImageDecoder"+                               , "UseTIFFImageDecoder"+                               , "UseZipPacker"+                               , "Val"+                               , "ValD"+                               , "ValF"+                               , "VertexPoseReferenceCount"+                               , "WaitProgram"+                               , "WaitSemaphore"+                               , "WaitThread"+                               , "WaitWindowEvent"+                               , "WaterColor"+                               , "WaterHeight"+                               , "WebGadget"+                               , "WebGadgetPath"+                               , "WindowBounds"+                               , "WindowEvent"+                               , "WindowEvent3D"+                               , "WindowHeight"+                               , "WindowHeight3D"+                               , "WindowID"+                               , "WindowID3D"+                               , "WindowMouseX"+                               , "WindowMouseY"+                               , "WindowOutput"+                               , "WindowWidth"+                               , "WindowWidth3D"+                               , "WindowX"+                               , "WindowX3D"+                               , "WindowY"+                               , "WindowY3D"+                               , "WorldCollisionAppliedImpulse"+                               , "WorldCollisionContact"+                               , "WorldCollisionNormal"+                               , "WorldDebug"+                               , "WorldGravity"+                               , "WorldShadows"+                               , "WriteAsciiCharacter"+                               , "WriteByte"+                               , "WriteCharacter"+                               , "WriteConsoleData"+                               , "WriteData"+                               , "WriteDouble"+                               , "WriteFloat"+                               , "WriteInteger"+                               , "WriteLong"+                               , "WritePreferenceDouble"+                               , "WritePreferenceFloat"+                               , "WritePreferenceInteger"+                               , "WritePreferenceLong"+                               , "WritePreferenceQuad"+                               , "WritePreferenceString"+                               , "WriteProgramData"+                               , "WriteProgramString"+                               , "WriteProgramStringN"+                               , "WriteQuad"+                               , "WriteSerialPortData"+                               , "WriteSerialPortString"+                               , "WriteString"+                               , "WriteStringFormat"+                               , "WriteStringN"+                               , "WriteUnicodeCharacter"+                               , "WriteWord"+                               , "XMLAttributeName"+                               , "XMLAttributeValue"+                               , "XMLChildCount"+                               , "XMLError"+                               , "XMLErrorLine"+                               , "XMLErrorPosition"+                               , "XMLNodeFromID"+                               , "XMLNodeFromPath"+                               , "XMLNodePath"+                               , "XMLNodeType"+                               , "XMLStatus"+                               , "Yaw"+                               , "Year"+                               , "ZoomSprite"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet False [ "CallDebugger" , "Debug" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\#+[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\#+[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PureBasic" , "String" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*;+\\s*BEGIN.*$"+                              , reCompiled = Just (compileRegex True "\\s*;+\\s*BEGIN.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*;+\\s*END.*$"+                              , reCompiled = Just (compileRegex True "\\s*;+\\s*END.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "PureBasic" , "Comment1" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "PureBasic"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor =+      "Alexander Clay (Tuireann@EpicBasic.org);Sven Langenkamp (ace@kylixforum.de)"+  , sVersion = "6"+  , sLicense = "LGPL"+  , sExtensions = [ "*.pb" , "*.pbi" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Python.hs view
@@ -0,0 +1,2796 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Python (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Python"+  , sFilename = "python.xml"+  , sShortname = "Python"+  , sContexts =+      fromList+        [ ( "#CheckForString"+          , Context+              { cName = "#CheckForString"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = LineContinue+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "CheckForStringNext" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "CheckForStringNext"+          , Context+              { cName = "CheckForStringNext"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = LineContinue+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "CheckForStringNext" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "StringVariants" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "CommentVariants"+          , Context+              { cName = "CommentVariants"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "u?'''"+                              , reCompiled = Just (compileRegex False "u?'''")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Triple A-comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "u?\"\"\""+                              , reCompiled = Just (compileRegex False "u?\"\"\"")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Triple Q-comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "u?'"+                              , reCompiled = Just (compileRegex False "u?'")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Single A-comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "u?\""+                              , reCompiled = Just (compileRegex False "u?\"")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Single Q-comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(u?r|ru)'''"+                              , reCompiled = Just (compileRegex False "(u?r|ru)'''")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Triple A-comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(u?r|ru)\"\"\""+                              , reCompiled = Just (compileRegex False "(u?r|ru)\"\"\"")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Triple Q-comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(u?r|ru)'"+                              , reCompiled = Just (compileRegex False "(u?r|ru)'")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Single A-comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(u?r|ru)\""+                              , reCompiled = Just (compileRegex False "(u?r|ru)\"")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Single Q-comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Dictionary"+          , Context+              { cName = "Dictionary"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "StringVariants" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Hash comment"+          , Context+              { cName = "Hash comment"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Modelines" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "List"+          , Context+              { cName = "List"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "StringVariants" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !#%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "as" , "from" , "import" ])+                      , rAttribute = ImportTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !#%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "class" , "def" , "del" , "global" , "lambda" , "nonlocal" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !#%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "and" , "in" , "is" , "not" , "or" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !#%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "assert"+                               , "async"+                               , "await"+                               , "break"+                               , "continue"+                               , "elif"+                               , "else"+                               , "except"+                               , "finally"+                               , "for"+                               , "if"+                               , "pass"+                               , "raise"+                               , "return"+                               , "try"+                               , "while"+                               , "with"+                               , "yield"+                               ])+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !#%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "__import__"+                               , "abs"+                               , "all"+                               , "any"+                               , "apply"+                               , "ascii"+                               , "basestring"+                               , "bin"+                               , "bool"+                               , "buffer"+                               , "bytearray"+                               , "bytes"+                               , "callable"+                               , "chr"+                               , "classmethod"+                               , "cmp"+                               , "coerce"+                               , "compile"+                               , "complex"+                               , "delattr"+                               , "dict"+                               , "dir"+                               , "divmod"+                               , "enumerate"+                               , "eval"+                               , "exec"+                               , "execfile"+                               , "file"+                               , "filter"+                               , "float"+                               , "format"+                               , "frozenset"+                               , "getattr"+                               , "globals"+                               , "hasattr"+                               , "hash"+                               , "help"+                               , "hex"+                               , "id"+                               , "input"+                               , "int"+                               , "intern"+                               , "isinstance"+                               , "issubclass"+                               , "iter"+                               , "len"+                               , "list"+                               , "locals"+                               , "long"+                               , "map"+                               , "max"+                               , "memoryview"+                               , "min"+                               , "next"+                               , "object"+                               , "oct"+                               , "open"+                               , "ord"+                               , "pow"+                               , "print"+                               , "property"+                               , "range"+                               , "raw_input"+                               , "reduce"+                               , "reload"+                               , "repr"+                               , "reversed"+                               , "round"+                               , "set"+                               , "setattr"+                               , "slice"+                               , "sorted"+                               , "staticmethod"+                               , "str"+                               , "sum"+                               , "super"+                               , "tuple"+                               , "type"+                               , "unichr"+                               , "unicode"+                               , "vars"+                               , "xrange"+                               , "zip"+                               ])+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !#%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Ellipsis"+                               , "False"+                               , "None"+                               , "NotImplemented"+                               , "True"+                               , "__debug__"+                               , "__file__"+                               , "__name__"+                               , "self"+                               ])+                      , rAttribute = VariableTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !#%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "SIGNAL" , "SLOT" , "connect" ])+                      , rAttribute = ExtensionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !#%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ArithmeticError"+                               , "AssertionError"+                               , "AttributeError"+                               , "BaseException"+                               , "BlockingIOError"+                               , "BrokenPipeError"+                               , "BufferError"+                               , "BytesWarning"+                               , "ChildProcessError"+                               , "ConnectionAbortedError"+                               , "ConnectionError"+                               , "ConnectionRefusedError"+                               , "ConnectionResetError"+                               , "DeprecationWarning"+                               , "EOFError"+                               , "EnvironmentError"+                               , "Exception"+                               , "FileExistsError"+                               , "FileNotFoundError"+                               , "FloatingPointError"+                               , "FutureWarning"+                               , "GeneratorExit"+                               , "IOError"+                               , "ImportError"+                               , "ImportWarning"+                               , "IndentationError"+                               , "IndexError"+                               , "InterruptedError"+                               , "IsADirectoryError"+                               , "KeyError"+                               , "KeyboardInterrupt"+                               , "LookupError"+                               , "MemoryError"+                               , "NameError"+                               , "NotADirectoryError"+                               , "NotImplementedError"+                               , "OSError"+                               , "OverflowError"+                               , "PendingDeprecationWarning"+                               , "PermissionError"+                               , "ProcessLookupError"+                               , "ReferenceError"+                               , "ResourceWarning"+                               , "RuntimeError"+                               , "RuntimeWarning"+                               , "StandardError"+                               , "StopIteration"+                               , "SyntaxError"+                               , "SyntaxWarning"+                               , "SystemError"+                               , "SystemExit"+                               , "TabError"+                               , "TimeoutError"+                               , "TypeError"+                               , "UnboundLocalError"+                               , "UnicodeDecodeError"+                               , "UnicodeEncodeError"+                               , "UnicodeError"+                               , "UnicodeTranslateError"+                               , "UnicodeWarning"+                               , "UserWarning"+                               , "ValueError"+                               , "Warning"+                               , "WindowsError"+                               , "ZeroDivisionError"+                               ])+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !#%&'()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "__abs__"+                               , "__add__"+                               , "__aenter__"+                               , "__aexit__"+                               , "__aiter__"+                               , "__and__"+                               , "__anext__"+                               , "__await__"+                               , "__bytes__"+                               , "__call__"+                               , "__cmp__"+                               , "__coerce__"+                               , "__complex__"+                               , "__contains__"+                               , "__del__"+                               , "__delattr__"+                               , "__delete__"+                               , "__delitem__"+                               , "__delslice__"+                               , "__dir__"+                               , "__div__"+                               , "__divmod__"+                               , "__enter__"+                               , "__eq__"+                               , "__exit__"+                               , "__float__"+                               , "__floordiv__"+                               , "__format__"+                               , "__ge__"+                               , "__get__"+                               , "__getattr__"+                               , "__getattribute__"+                               , "__getitem__"+                               , "__getslice__"+                               , "__gt__"+                               , "__hash__"+                               , "__hex__"+                               , "__iadd__"+                               , "__iand__"+                               , "__idiv__"+                               , "__ifloordiv__"+                               , "__ilshift__"+                               , "__imod__"+                               , "__imul__"+                               , "__index__"+                               , "__init__"+                               , "__int__"+                               , "__invert__"+                               , "__ior__"+                               , "__ipow__"+                               , "__irshift__"+                               , "__isub__"+                               , "__iter__"+                               , "__itruediv__"+                               , "__ixor__"+                               , "__le__"+                               , "__len__"+                               , "__long__"+                               , "__lshift__"+                               , "__lt__"+                               , "__mod__"+                               , "__mul__"+                               , "__ne__"+                               , "__neg__"+                               , "__new__"+                               , "__next__"+                               , "__nonzero__"+                               , "__oct__"+                               , "__or__"+                               , "__pos__"+                               , "__pow__"+                               , "__radd__"+                               , "__rand__"+                               , "__rcmp__"+                               , "__rdiv__"+                               , "__rdivmod__"+                               , "__repr__"+                               , "__reversed__"+                               , "__rfloordiv__"+                               , "__rlshift__"+                               , "__rmod__"+                               , "__rmul__"+                               , "__ror__"+                               , "__rpow__"+                               , "__rrshift__"+                               , "__rshift__"+                               , "__rsub__"+                               , "__rtruediv__"+                               , "__rxor__"+                               , "__set__"+                               , "__setattr__"+                               , "__setitem__"+                               , "__setslice__"+                               , "__str__"+                               , "__sub__"+                               , "__truediv__"+                               , "__unicode__"+                               , "__xor__"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z_][a-zA-Z_0-9]{2,}"+                              , reCompiled = Just (compileRegex True "[a-zA-Z_][a-zA-Z_0-9]{2,}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  " ((([0-9]*\\.[0-9]+|[0-9]+\\.)|([0-9]+|([0-9]*\\.[0-9]+|[0-9]+\\.))[eE](\\+|-)?[0-9]+)|[0-9]+)[jJ]"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       " ((([0-9]*\\.[0-9]+|[0-9]+\\.)|([0-9]+|([0-9]*\\.[0-9]+|[0-9]+\\.))[eE](\\+|-)?[0-9]+)|[0-9]+)[jJ]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren =+                          [ Rule+                              { rMatcher = StringDetect "L"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Dictionary" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "List" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Tuple" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "CommentVariants" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Hash comment" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "StringVariants" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@[_a-zA-Z][\\._a-zA-Z0-9]*"+                              , reCompiled =+                                  Just (compileRegex True "@[_a-zA-Z][\\._a-zA-Z0-9]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "+*/%\\|=;\\!<>!^&~-@"+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Raw A-F-String"+          , Context+              { cName = "Raw A-F-String"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "stringinterpolation" )+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Python" , "#CheckForString" ) ]+                      }+                  ]+              , cAttribute = VerbatimStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Raw A-string"+          , Context+              { cName = "Raw A-string"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "stringformat" )+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Python" , "#CheckForString" ) ]+                      }+                  ]+              , cAttribute = VerbatimStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Raw Q-F-String"+          , Context+              { cName = "Raw Q-F-String"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "stringinterpolation" )+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Python" , "#CheckForString" ) ]+                      }+                  ]+              , cAttribute = VerbatimStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Raw Q-string"+          , Context+              { cName = "Raw Q-string"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "stringformat" )+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Python" , "#CheckForString" ) ]+                      }+                  ]+              , cAttribute = VerbatimStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Raw Triple A-F-String"+          , Context+              { cName = "Raw Triple A-F-String"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "stringinterpolation" )+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "'''"+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Python" , "#CheckForString" ) ]+                      }+                  ]+              , cAttribute = VerbatimStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Raw Triple A-string"+          , Context+              { cName = "Raw Triple A-string"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "stringformat" )+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "'''"+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Python" , "#CheckForString" ) ]+                      }+                  ]+              , cAttribute = VerbatimStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Raw Triple Q-F-String"+          , Context+              { cName = "Raw Triple Q-F-String"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "stringinterpolation" )+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "\"\"\""+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Python" , "#CheckForString" ) ]+                      }+                  ]+              , cAttribute = VerbatimStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Raw Triple Q-string"+          , Context+              { cName = "Raw Triple Q-string"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "stringformat" )+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "\"\"\""+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Python" , "#CheckForString" ) ]+                      }+                  ]+              , cAttribute = VerbatimStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Single A-F-String"+          , Context+              { cName = "Single A-F-String"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Python" , "stringescape" )+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "stringinterpolation" )+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Python" , "#CheckForString" ) ]+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Single A-comment"+          , Context+              { cName = "Single A-comment"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts_indent" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Single A-string"+          , Context+              { cName = "Single A-string"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Python" , "stringescape" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "stringformat" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Python" , "#CheckForString" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Single Q-F-String"+          , Context+              { cName = "Single Q-F-String"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Python" , "stringescape" )+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "stringinterpolation" )+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Python" , "#CheckForString" ) ]+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Single Q-comment"+          , Context+              { cName = "Single Q-comment"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts_indent" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Single Q-string"+          , Context+              { cName = "Single Q-string"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Python" , "stringescape" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "stringformat" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Python" , "#CheckForString" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String Interpolation"+          , Context+              { cName = "String Interpolation"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(![rs])?(:([^}]?[<>=^])?[ +-]?#?0?[0-9]*(\\.[0-9]+)?[bcdeEfFgGnosxX%]?)?\\}"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(![rs])?(:([^}]?[<>=^])?[ +-]?#?0?[0-9]*(\\.[0-9]+)?[bcdeEfFgGnosxX%]?)?\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "Normal" )+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = SpecialCharTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "StringVariants"+          , Context+              { cName = "StringVariants"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "u?'''"+                              , reCompiled = Just (compileRegex False "u?'''")+                              , reCaseSensitive = False+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Triple A-string" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "u?\"\"\""+                              , reCompiled = Just (compileRegex False "u?\"\"\"")+                              , reCaseSensitive = False+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Triple Q-string" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "u?'"+                              , reCompiled = Just (compileRegex False "u?'")+                              , reCaseSensitive = False+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Single A-string" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "u?\""+                              , reCompiled = Just (compileRegex False "u?\"")+                              , reCaseSensitive = False+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Single Q-string" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(u?r|ru)'''"+                              , reCompiled = Just (compileRegex False "(u?r|ru)'''")+                              , reCaseSensitive = False+                              }+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Raw Triple A-string" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(u?r|ru)\"\"\""+                              , reCompiled = Just (compileRegex False "(u?r|ru)\"\"\"")+                              , reCaseSensitive = False+                              }+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Raw Triple Q-string" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(u?r|ru)'"+                              , reCompiled = Just (compileRegex False "(u?r|ru)'")+                              , reCaseSensitive = False+                              }+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Raw A-string" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(u?r|ru)\""+                              , reCompiled = Just (compileRegex False "(u?r|ru)\"")+                              , reCaseSensitive = False+                              }+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Raw Q-string" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "f'''"+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Triple A-F-String" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "f\"\"\""+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Triple Q-F-String" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "f'"+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Single A-F-String" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "f\""+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Single Q-F-String" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(fr|rf)'''"+                              , reCompiled = Just (compileRegex False "(fr|rf)'''")+                              , reCaseSensitive = False+                              }+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Raw Triple A-F-String" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(fr|rf)\"\"\""+                              , reCompiled = Just (compileRegex False "(fr|rf)\"\"\"")+                              , reCaseSensitive = False+                              }+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Raw Triple Q-F-String" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(fr|rf)'"+                              , reCompiled = Just (compileRegex False "(fr|rf)'")+                              , reCaseSensitive = False+                              }+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Raw A-F-String" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(fr|rf)\""+                              , reCompiled = Just (compileRegex False "(fr|rf)\"")+                              , reCaseSensitive = False+                              }+                      , rAttribute = VerbatimStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "Raw Q-F-String" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Triple A-F-String"+          , Context+              { cName = "Triple A-F-String"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Python" , "stringescape" )+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "stringinterpolation" )+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "'''"+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Python" , "#CheckForString" ) ]+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Triple A-comment"+          , Context+              { cName = "Triple A-comment"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "'''"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts_indent" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Triple A-string"+          , Context+              { cName = "Triple A-string"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Python" , "stringescape" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "stringformat" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "'''"+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Python" , "#CheckForString" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Triple Q-F-String"+          , Context+              { cName = "Triple Q-F-String"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Python" , "stringescape" )+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "stringinterpolation" )+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "\"\"\""+                      , rAttribute = SpecialStringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Python" , "#CheckForString" ) ]+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Triple Q-comment"+          , Context+              { cName = "Triple Q-comment"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = HlCChar+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "\"\"\""+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts_indent" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Triple Q-string"+          , Context+              { cName = "Triple Q-string"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Python" , "stringescape" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "stringformat" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "\"\"\""+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Push ( "Python" , "#CheckForString" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Tuple"+          , Context+              { cName = "Tuple"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "StringVariants" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Python" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "stringescape"+          , Context+              { cName = "stringescape"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[\\\\'\"abfnrtv]"+                              , reCompiled = Just (compileRegex True "\\\\[\\\\'\"abfnrtv]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[0-7]{1,3}"+                              , reCompiled = Just (compileRegex True "\\\\[0-7]{1,3}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\x[0-9A-Fa-f]{2}"+                              , reCompiled = Just (compileRegex True "\\\\x[0-9A-Fa-f]{2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\u[0-9A-Fa-f]{4}"+                              , reCompiled = Just (compileRegex True "\\\\u[0-9A-Fa-f]{4}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\U[0-9A-Fa-f]{8}"+                              , reCompiled = Just (compileRegex True "\\\\U[0-9A-Fa-f]{8}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\N\\{[a-zA-Z0-9\\- ]+\\}"+                              , reCompiled =+                                  Just (compileRegex True "\\\\N\\{[a-zA-Z0-9\\- ]+\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CharTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "stringformat"+          , Context+              { cName = "stringformat"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "%((\\([a-zA-Z0-9_]+\\))?[#0\\- +]?([1-9][0-9]*|\\*)?(\\.([1-9][0-9]*|\\*))?[hlL]?[crsdiouxXeEfFgG%]|prog|default)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "%((\\([a-zA-Z0-9_]+\\))?[#0\\- +]?([1-9][0-9]*|\\*)?(\\.([1-9][0-9]*|\\*))?[hlL]?[crsdiouxXeEfFgG%]|prog|default)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\{(([a-zA-Z0-9_]+|[0-9]+)(\\.[a-zA-Z0-9_]+|\\[[^ \\]]+\\])*)?(![rs])?(:([^}]?[<>=^])?[ +-]?#?0?[0-9]*(\\.[0-9]+)?[bcdeEfFgGnosxX%]?)?\\}"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\{(([a-zA-Z0-9_]+|[0-9]+)(\\.[a-zA-Z0-9_]+|\\[[^ \\]]+\\])*)?(![rs])?(:([^}]?[<>=^])?[ +-]?#?0?[0-9]*(\\.[0-9]+)?[bcdeEfFgGnosxX%]?)?\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '{' '{'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '}' '}'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = SpecialCharTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "stringinterpolation"+          , Context+              { cName = "stringinterpolation"+              , cSyntax = "Python"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '{' '{'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Python" , "String Interpolation" ) ]+                      }+                  ]+              , cAttribute = SpecialStringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Michael Bueker"+  , sVersion = "4"+  , sLicense = ""+  , sExtensions = [ "*.py" , "*.pyw" , "SConstruct" , "SConscript" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/R.hs view
@@ -0,0 +1,799 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.R (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "R Script"+  , sFilename = "r.xml"+  , sShortname = "R"+  , sContexts =+      fromList+        [ ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "R Script"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CommonRules"+          , Context+              { cName = "CommonRules"+              , cSyntax = "R Script"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "R Script" , "string" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "R Script" , "string2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "R Script" , "backquotedsymbol" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !$%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "break"+                               , "else"+                               , "for"+                               , "function"+                               , "if"+                               , "in"+                               , "next"+                               , "repeat"+                               , "switch"+                               , "while"+                               ])+                      , rAttribute = ControlFlowTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !$%&()*+,-/:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "FALSE"+                               , "Inf"+                               , "NA"+                               , "NA_character_"+                               , "NA_complex_"+                               , "NA_integer_"+                               , "NA_real_"+                               , "NULL"+                               , "NaN"+                               , "TRUE"+                               ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z_]+[a-zA-Z_\\.0-9]*(?=[\\s]*[(])"+                              , reCompiled =+                                  Just (compileRegex True "[a-zA-Z_]+[a-zA-Z_\\.0-9]*(?=[\\s]*[(])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.[a-zA-Z_\\.]+[a-zA-Z_\\.0-9]*(?=[\\s]*[(])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\.[a-zA-Z_\\.]+[a-zA-Z_\\.0-9]*(?=[\\s]*[(])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\("+                              , reCompiled = Just (compileRegex True "\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "R Script" , "parenthesis" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "##"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "R Script" , "Headline" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "R Script" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[<]{1,2}\\-"+                              , reCompiled = Just (compileRegex True "[<]{1,2}\\-")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "R Script" , "operator_rhs" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\-[>]{1,2}"+                              , reCompiled = Just (compileRegex True "\\-[>]{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "R Script" , "operator_rhs" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "=(?!=)"+                              , reCompiled = Just (compileRegex True "=(?!=)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "R Script" , "operator_rhs" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\+|\\-|\\*{1,2}|/|<=?|>=?|={1,2}|\\!=?|\\|{1,2}|&{1,2}|:{1,3}|\\^|@|\\$|~)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(\\+|\\-|\\*{1,2}|/|<=?|>=?|={1,2}|\\!=?|\\|{1,2}|&{1,2}|:{1,3}|\\^|@|\\$|~)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "R Script" , "operator_rhs" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%[^%]*%"+                              , reCompiled = Just (compileRegex True "%[^%]*%")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "R Script" , "operator_rhs" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "R Script" , "ctx0" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Headline"+          , Context+              { cName = "Headline"+              , cSyntax = "R Script"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "backquotedsymbol"+          , Context+              { cName = "backquotedsymbol"+              , cSyntax = "R Script"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ctx0"+          , Context+              { cName = "ctx0"+              , cSyntax = "R Script"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "R Script" , "CommonRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "level0"+          , Context+              { cName = "level0"+              , cSyntax = "R Script"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "R Script" , "CommonRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "operator_rhs"+          , Context+              { cName = "operator_rhs"+              , cSyntax = "R Script"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "##"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "R Script" , "Headline" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "R Script" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ' '+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\*|/|<|>|\\!=|=|\\||&|:|\\^|@|\\$|~)"+                              , reCompiled =+                                  Just (compileRegex True "(\\*|/|<|>|\\!=|=|\\||&|:|\\^|@|\\$|~)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "parenthesis"+          , Context+              { cName = "parenthesis"+              , cSyntax = "R Script"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z_\\.][0-9a-zA-Z_\\.]*[\\s]*=(?=([^=]|$))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "[a-zA-Z_\\.][0-9a-zA-Z_\\.]*[\\s]*=(?=([^=]|$))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "R Script" , "CommonRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "string"+          , Context+              { cName = "string"+              , cSyntax = "R Script"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "string2"+          , Context+              { cName = "string2"+              , cSyntax = "R Script"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = ""+  , sVersion = "6"+  , sLicense = "GPLv2"+  , sExtensions = [ "*.R" , "*.r" , "*.S" , "*.s" , "*.q" ]+  , sStartingContext = "level0"+  }
+ src/Skylighting/Syntax/Relaxng.hs view
@@ -0,0 +1,440 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Relaxng (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "RELAX NG"+  , sFilename = "relaxng.xml"+  , sShortname = "Relaxng"+  , sContexts =+      fromList+        [ ( "attrValue"+          , Context+              { cName = "attrValue"+              , cSyntax = "RELAX NG"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "RELAX NG" , "string" ) ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "attributes"+          , Context+              { cName = "attributes"+              , cSyntax = "RELAX NG"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*=\\s*"+                              , reCompiled = Just (compileRegex True "\\s*=\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "RELAX NG" , "attrValue" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "comment"+          , Context+              { cName = "comment"+              , cSyntax = "RELAX NG"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "-->"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-(-(?!->))+"+                              , reCompiled = Just (compileRegex True "-(-(?!->))+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "detectEntRef"+          , Context+              { cName = "detectEntRef"+              , cSyntax = "RELAX NG"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "normalText"+          , Context+              { cName = "normalText"+              , cSyntax = "RELAX NG"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "RELAX NG" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "RELAX NG" , "tagname" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "string"+          , Context+              { cName = "string"+              , cSyntax = "RELAX NG"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "RELAX NG" , "detectEntRef" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "tagname"+          , Context+              { cName = "tagname"+              , cSyntax = "RELAX NG"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&()*+,./;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "anyName"+                               , "attribute"+                               , "choice"+                               , "data"+                               , "define"+                               , "div"+                               , "element"+                               , "empty"+                               , "except"+                               , "externalRef"+                               , "grammar"+                               , "group"+                               , "include"+                               , "interleave"+                               , "list"+                               , "mixed"+                               , "name"+                               , "notAllowed"+                               , "nsName"+                               , "oneOrMore"+                               , "optional"+                               , "param"+                               , "parentRef"+                               , "ref"+                               , "start"+                               , "text"+                               , "value"+                               , "zeroOrMore"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "RELAX NG" , "attributes" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*"+                              , reCompiled = Just (compileRegex True "\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "RELAX NG" , "attributes" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Thomas Schraitle (tom_schr AT web DOT de)"+  , sVersion = "1"+  , sLicense = "LGPL"+  , sExtensions = [ "*.rng" , "*.RNG" ]+  , sStartingContext = "normalText"+  }
+ src/Skylighting/Syntax/Relaxngcompact.hs view
@@ -0,0 +1,293 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Relaxngcompact (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "RelaxNG-Compact"+  , sFilename = "relaxngcompact.xml"+  , sShortname = "Relaxngcompact"+  , sContexts =+      fromList+        [ ( "Comments"+          , Context+              { cName = "Comments"+              , cSyntax = "RelaxNG-Compact"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Definitions"+          , Context+              { cName = "Definitions"+              , cSyntax = "RelaxNG-Compact"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Node Names"+          , Context+              { cName = "Node Names"+              , cSyntax = "RelaxNG-Compact"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal Text"+          , Context+              { cName = "Normal Text"+              , cSyntax = "RelaxNG-Compact"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "RelaxNG-Compact" , "Comments" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "RelaxNG-Compact" , "String" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,./;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "datatypes"+                               , "default"+                               , "div"+                               , "empty"+                               , "external"+                               , "grammar"+                               , "include"+                               , "inherit"+                               , "list"+                               , "mixed"+                               , "namespace"+                               , "notAllowed"+                               , "parent"+                               , "start"+                               , "token"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,./;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "attribute" , "element" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "RelaxNG-Compact" , "Node Names" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !%&()*+,./;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "string"+                               , "text"+                               , "xsd:ENTITIES"+                               , "xsd:ENTITY"+                               , "xsd:ID"+                               , "xsd:IDREF"+                               , "xsd:IDREFS"+                               , "xsd:NCName"+                               , "xsd:NMTOKEN"+                               , "xsd:NMTOKENS"+                               , "xsd:NOTATION"+                               , "xsd:Name"+                               , "xsd:QName"+                               , "xsd:anyURI"+                               , "xsd:base64Binary"+                               , "xsd:boolean"+                               , "xsd:byte"+                               , "xsd:date"+                               , "xsd:dateTime"+                               , "xsd:decimal"+                               , "xsd:double"+                               , "xsd:duration"+                               , "xsd:float"+                               , "xsd:gDay"+                               , "xsd:gMonth"+                               , "xsd:gMonthDay"+                               , "xsd:gYear"+                               , "xsd:gYearMonth"+                               , "xsd:hexBinary"+                               , "xsd:int"+                               , "xsd:integer"+                               , "xsd:language"+                               , "xsd:long"+                               , "xsd:negativeInteger"+                               , "xsd:nonNegativeInteger"+                               , "xsd:nonPositiveInteger"+                               , "xsd:normalizedString"+                               , "xsd:positiveInteger"+                               , "xsd:short"+                               , "xsd:string"+                               , "xsd:time"+                               , "xsd:token"+                               , "xsd:unsignedByte"+                               , "xsd:unsignedInt"+                               , "xsd:unsignedLong"+                               , "xsd:unsignedShort"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\w\\.-]+[\\s]+="+                              , reCompiled = Just (compileRegex True "[\\w\\.-]+[\\s]+=")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "RelaxNG-Compact" , "Definitions" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "RelaxNG-Compact"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Rintze Zelle"+  , sVersion = "1"+  , sLicense = "LGPL"+  , sExtensions = [ "*.rnc" ]+  , sStartingContext = "Normal Text"+  }
+ src/Skylighting/Syntax/Rest.hs view
@@ -0,0 +1,794 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Rest (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex++syntax :: Syntax+syntax = Syntax+  { sName = "reStructuredText"+  , sFilename = "rest.xml"+  , sShortname = "Rest"+  , sContexts =+      fromList+        [ ( "Code"+          , Context+              { cName = "Code"+              , cSyntax = "reStructuredText"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1" , reCompiled = Nothing , reCaseSensitive = True }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(.|$)"+                              , reCompiled = Just (compileRegex True "(.|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "CodeBlock"+          , Context+              { cName = "CodeBlock"+              , cSyntax = "reStructuredText"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\s+)(?=\\S)"+                              , reCompiled = Just (compileRegex True "(\\s+)(?=\\S)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "reStructuredText" , "Code" ) ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "reStructuredText"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1   "+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(.|$)"+                              , reCompiled = Just (compileRegex True "(.|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "Field"+          , Context+              { cName = "Field"+              , cSyntax = "reStructuredText"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ':'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(^|[-\\s'\"\\(\\[{</:\226\128\152\226\128\156\226\128\153\194\171\194\161\194\191\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 ])\\*\\*[^\\s].*\\*\\*(?=[-\\s\226\128\153\226\128\157\194\187\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 '\"\\)\\]}>/:\\.,;!\\?\\\\]|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(^|[-\\s'\"\\(\\[{</:\226\128\152\226\128\156\226\128\153\194\171\194\161\194\191\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 ])\\*\\*[^\\s].*\\*\\*(?=[-\\s\226\128\153\226\128\157\194\187\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 '\"\\)\\]}>/:\\.,;!\\?\\\\]|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(^|[-\\s'\"\\(\\[{</:\226\128\152\226\128\156\226\128\153\194\171\194\161\194\191\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 ])\\*[^\\s].*\\*(?=[-\\s\226\128\153\226\128\157\194\187\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 '\"\\)\\]}>/:\\.,;!\\?\\\\]|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(^|[-\\s'\"\\(\\[{</:\226\128\152\226\128\156\226\128\153\194\171\194\161\194\191\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 ])\\*[^\\s].*\\*(?=[-\\s\226\128\153\226\128\157\194\187\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 '\"\\)\\]}>/:\\.,;!\\?\\\\]|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "reStructuredText" , "InlineMarkup" )+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "InlineMarkup"+          , Context+              { cName = "InlineMarkup"+              , cSyntax = "reStructuredText"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(^|[-\\s'\"\\(\\[{</:\226\128\152\226\128\156\226\128\153\194\171\194\161\194\191\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 ])``[^\\s].*``(?=[-\\s\226\128\153\226\128\157\194\187\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 '\"\\)\\]}>/:\\.,;!\\?\\\\]|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(^|[-\\s'\"\\(\\[{</:\226\128\152\226\128\156\226\128\153\194\171\194\161\194\191\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 ])``[^\\s].*``(?=[-\\s\226\128\153\226\128\157\194\187\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 '\"\\)\\]}>/:\\.,;!\\?\\\\]|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(^|[-\\s'\"\\(\\[{</:\226\128\152\226\128\156\226\128\153\194\171\194\161\194\191\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 ])\\|[^\\s].*\\|(?=[-\\s\226\128\153\226\128\157\194\187\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 '\"\\)\\]}>/:\\.,;!\\?\\\\]|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(^|[-\\s'\"\\(\\[{</:\226\128\152\226\128\156\226\128\153\194\171\194\161\194\191\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 ])\\|[^\\s].*\\|(?=[-\\s\226\128\153\226\128\157\194\187\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 '\"\\)\\]}>/:\\.,;!\\?\\\\]|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(^|[-\\s'\"\\(\\[{</:\226\128\152\226\128\156\226\128\153\194\171\194\161\194\191\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 ])_`[^\\s].*`(?=[-\\s\226\128\153\226\128\157\194\187\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 '\"\\)\\]}>/:\\.,;!\\?\\\\]|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(^|[-\\s'\"\\(\\[{</:\226\128\152\226\128\156\226\128\153\194\171\194\161\194\191\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 ])_`[^\\s].*`(?=[-\\s\226\128\153\226\128\157\194\187\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 '\"\\)\\]}>/:\\.,;!\\?\\\\]|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(^|[-\\s'\"\\(\\[{</:\226\128\152\226\128\156\226\128\153\194\171\194\161\194\191\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 ])\\[[\\w_\\.:\\+\\-]+\\]_(?=[-\\s\226\128\153\226\128\157\194\187\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 '\"\\)\\]}>/:\\.,;!\\?\\\\]|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(^|[-\\s'\"\\(\\[{</:\226\128\152\226\128\156\226\128\153\194\171\194\161\194\191\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 ])\\[[\\w_\\.:\\+\\-]+\\]_(?=[-\\s\226\128\153\226\128\157\194\187\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 '\"\\)\\]}>/:\\.,;!\\?\\\\]|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(^|[-\\s'\"\\(\\[{</:\226\128\152\226\128\156\226\128\153\194\171\194\161\194\191\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 ])`[^\\s].*`_(?=[-\\s\226\128\153\226\128\157\194\187\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 '\"\\)\\]}>/:\\.,;!\\?\\\\]|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(^|[-\\s'\"\\(\\[{</:\226\128\152\226\128\156\226\128\153\194\171\194\161\194\191\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 ])`[^\\s].*`_(?=[-\\s\226\128\153\226\128\157\194\187\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 '\"\\)\\]}>/:\\.,;!\\?\\\\]|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(^|[-\\s'\"\\(\\[{</:\226\128\152\226\128\156\226\128\153\194\171\194\161\194\191\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 ])\\w+_(?=[-\\s\226\128\153\226\128\157\194\187\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 '\"\\)\\]}>/:\\.,;!\\?\\\\]|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(^|[-\\s'\"\\(\\[{</:\226\128\152\226\128\156\226\128\153\194\171\194\161\194\191\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 ])\\w+_(?=[-\\s\226\128\153\226\128\157\194\187\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 '\"\\)\\]}>/:\\.,;!\\?\\\\]|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(^|[-\\s'\"\\(\\[{</:\226\128\152\226\128\156\226\128\153\194\171\194\161\194\191\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 ])`[^\\s].*`(?=:[\\w-_\\.\\+]+:)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(^|[-\\s'\"\\(\\[{</:\226\128\152\226\128\156\226\128\153\194\171\194\161\194\191\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 ])`[^\\s].*`(?=:[\\w-_\\.\\+]+:)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "reStructuredText" , "TrailingRole" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ":[\\w-_\\.\\+]+:(?=`)"+                              , reCompiled = Just (compileRegex True ":[\\w-_\\.\\+]+:(?=`)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "reStructuredText" , "Role" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "InterpretedText"+          , Context+              { cName = "InterpretedText"+              , cSyntax = "reStructuredText"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = DecValTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "reStructuredText"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(^|[-\\s'\"\\(\\[{</:\226\128\152\226\128\156\226\128\153\194\171\194\161\194\191\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 ])\\*\\*[^\\s].*\\*\\*(?=[-\\s\226\128\153\226\128\157\194\187\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 '\"\\)\\]}>/:\\.,;!\\?\\\\]|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(^|[-\\s'\"\\(\\[{</:\226\128\152\226\128\156\226\128\153\194\171\194\161\194\191\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 ])\\*\\*[^\\s].*\\*\\*(?=[-\\s\226\128\153\226\128\157\194\187\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 '\"\\)\\]}>/:\\.,;!\\?\\\\]|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(^|[-\\s'\"\\(\\[{</:\226\128\152\226\128\156\226\128\153\194\171\194\161\194\191\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 ])\\*[^\\s].*\\*(?=[-\\s\226\128\153\226\128\157\194\187\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 '\"\\)\\]}>/:\\.,;!\\?\\\\]|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(^|[-\\s'\"\\(\\[{</:\226\128\152\226\128\156\226\128\153\194\171\194\161\194\191\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 ])\\*[^\\s].*\\*(?=[-\\s\226\128\153\226\128\157\194\187\226\128\144\226\128\145\226\128\146\226\128\147\226\128\148 '\"\\)\\]}>/:\\.,;!\\?\\\\]|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "reStructuredText" , "InlineMarkup" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\.\\. \\[(\\d+|#|\\*|#[\\w_\\.:\\+\\-]+)\\]\\s"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\s*\\.\\. \\[(\\d+|#|\\*|#[\\w_\\.:\\+\\-]+)\\]\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\.\\. \\[[\\w_\\.:\\+\\-]+\\]\\s"+                              , reCompiled =+                                  Just (compileRegex True "\\s*\\.\\. \\[[\\w_\\.:\\+\\-]+\\]\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*(\\.\\. (__:|_[\\w_\\.:\\+\\- ]+:(\\s|$))|__ )"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\s*(\\.\\. (__:|_[\\w_\\.:\\+\\- ]+:(\\s|$))|__ )")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\.\\. code-block::"+                              , reCompiled = Just (compileRegex True "\\s*\\.\\. code-block::")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "reStructuredText" , "CodeBlock" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*\\.\\. [\\w-_\\.]+::(\\s|$)"+                              , reCompiled =+                                  Just (compileRegex True "\\s*\\.\\. [\\w-_\\.]+::(\\s|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "::$"+                              , reCompiled = Just (compileRegex True "::$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "reStructuredText" , "CodeBlock" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\s*\\.\\. \\|[\\w_\\.:\\+\\- ]+\\|\\s+[\\w_\\.:\\+\\-]+::\\s"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\s*\\.\\. \\|[\\w_\\.:\\+\\- ]+\\|\\s+[\\w_\\.:\\+\\-]+::\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ":(?=([^:]*\\\\:)*[^:]*:(\\s|$))"+                              , reCompiled =+                                  Just (compileRegex True ":(?=([^:]*\\\\:)*[^:]*:(\\s|$))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "reStructuredText" , "Field" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\s*)\\.\\.\\s(?![\\w-_\\.]+::(\\s|$))"+                              , reCompiled =+                                  Just (compileRegex True "(\\s*)\\.\\.\\s(?![\\w-_\\.]+::(\\s|$))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "reStructuredText" , "Comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Role"+          , Context+              { cName = "Role"+              , cSyntax = "reStructuredText"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Pop , Push ( "reStructuredText" , "InterpretedText" ) ]+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "TrailingRole"+          , Context+              { cName = "TrailingRole"+              , cSyntax = "reStructuredText"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ":[\\w-_\\.\\+]+:"+                              , reCompiled = Just (compileRegex True ":[\\w-_\\.\\+]+:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = ""+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.rst" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Rhtml.hs view
@@ -0,0 +1,7978 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Rhtml (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Ruby/Rails/RHTML"+  , sFilename = "rhtml.xml"+  , sShortname = "Rhtml"+  , sContexts =+      fromList+        [ ( "Apostrophed String"+          , Context+              { cName = "Apostrophed String"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "\\\\"+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\\\'"+                              , reCompiled = Just (compileRegex True "\\\\\\'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CDATA"+          , Context+              { cName = "CDATA"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "]]>"+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "]]&gt;"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CSS"+          , Context+              { cName = "CSS"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%=?"+                              , reCompiled = Just (compileRegex True "<%=?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "rubysource" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "CSS content" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "FindAttributes" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CSS content"+          , Context+              { cName = "CSS content"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%=?"+                              , reCompiled = Just (compileRegex True "<%=?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "rubysource" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</style\\b"+                              , reCompiled = Just (compileRegex False "</style\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "El Close 2" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "CSS" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = True+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Command String"+          , Context+              { cName = "Command String"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "\\\\"+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\\\`"+                              , reCompiled = Just (compileRegex True "\\\\\\`")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#@{1,2}"+                              , reCompiled = Just (compileRegex True "#@{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "Short Subst" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "Subst" ) ]+                      }+                  , Rule+                      { rMatcher = HlCChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "-->"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-(-(?!->))+"+                              , reCompiled = Just (compileRegex True "-(-(?!->))+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment Line"+          , Context+              { cName = "Comment Line"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\w\\:\\:\\s"+                              , reCompiled = Just (compileRegex True "\\w\\:\\:\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "RDoc Label" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&()*+,-./:;<=>[\\]^{|}~"+                              }+                            (makeWordSet True [ "FIXME" , "NOTE" , "TODO" ])+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-?%>"+                              , reCompiled = Just (compileRegex True "-?%>")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DATA"+          , Context+              { cName = "DATA"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules = []+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype"+          , Context+              { cName = "Doctype"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "Doctype Internal Subset" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Internal Subset"+          , Context+              { cName = "Doctype Internal Subset"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "FindDTDRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\?[\\w:-]*"+                              , reCompiled = Just (compileRegex True "<\\?[\\w:-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "PI" ) ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "FindPEntityRefs" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Markupdecl"+          , Context+              { cName = "Doctype Markupdecl"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "Doctype Markupdecl DQ" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "Doctype Markupdecl SQ" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Markupdecl DQ"+          , Context+              { cName = "Doctype Markupdecl DQ"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%=?"+                              , reCompiled = Just (compileRegex True "<%=?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "rubysource" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "FindPEntityRefs" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Markupdecl SQ"+          , Context+              { cName = "Doctype Markupdecl SQ"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%=?"+                              , reCompiled = Just (compileRegex True "<%=?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "rubysource" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "FindPEntityRefs" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "El Close"+          , Context+              { cName = "El Close"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%=?"+                              , reCompiled = Just (compileRegex True "<%=?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "rubysource" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "El Close 2"+          , Context+              { cName = "El Close 2"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%=?"+                              , reCompiled = Just (compileRegex True "<%=?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "rubysource" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "El Close 3"+          , Context+              { cName = "El Close 3"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%=?"+                              , reCompiled = Just (compileRegex True "<%=?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "rubysource" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "El Open"+          , Context+              { cName = "El Open"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%=?"+                              , reCompiled = Just (compileRegex True "<%=?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "rubysource" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "FindAttributes" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Embedded documentation"+          , Context+              { cName = "Embedded documentation"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "=end"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindAttributes"+          , Context+              { cName = "FindAttributes"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Za-z_:][\\w.:_-]*"+                              , reCompiled = Just (compileRegex True "[A-Za-z_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+[A-Za-z_:][\\w.:_-]*"+                              , reCompiled = Just (compileRegex True "\\s+[A-Za-z_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "Value" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindDTDRules"+          , Context+              { cName = "FindDTDRules"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<!(ELEMENT|ENTITY|ATTLIST|NOTATION)\\b"+                              , reCompiled =+                                  Just (compileRegex True "<!(ELEMENT|ENTITY|ATTLIST|NOTATION)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "Doctype Markupdecl" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindEntityRefs"+          , Context+              { cName = "FindEntityRefs"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "&<"+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindHTML"+          , Context+              { cName = "FindHTML"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%=?"+                              , reCompiled = Just (compileRegex True "<%=?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "rubysource" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "%"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "rubysourceline" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<![CDATA["+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "CDATA" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<!DOCTYPE\\s+"+                              , reCompiled = Just (compileRegex True "<!DOCTYPE\\s+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "Doctype" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\?[\\w:-]*"+                              , reCompiled = Just (compileRegex True "<\\?[\\w:-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "PI" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<style\\b"+                              , reCompiled = Just (compileRegex False "<style\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "CSS" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<script\\b"+                              , reCompiled = Just (compileRegex False "<script\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "JS" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<pre\\b"+                              , reCompiled = Just (compileRegex False "<pre\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<div\\b"+                              , reCompiled = Just (compileRegex False "<div\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<table\\b"+                              , reCompiled = Just (compileRegex False "<table\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<[A-Za-z_:][\\w.:_-]*"+                              , reCompiled = Just (compileRegex True "<[A-Za-z_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "El Open" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</pre\\b"+                              , reCompiled = Just (compileRegex False "</pre\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</div\\b"+                              , reCompiled = Just (compileRegex False "</div\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</table\\b"+                              , reCompiled = Just (compileRegex False "</table\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</[A-Za-z_:][\\w.:_-]*"+                              , reCompiled = Just (compileRegex True "</[A-Za-z_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "El Close" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "FindDTDRules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "FindEntityRefs" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindPEntityRefs"+          , Context+              { cName = "FindPEntityRefs"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%[A-Za-z_:][\\w.:_-]*;"+                              , reCompiled = Just (compileRegex True "%[A-Za-z_:][\\w.:_-]*;")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "&%"+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "General Comment"+          , Context+              { cName = "General Comment"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&()*+,-./:;<=>[\\]^{|}~"+                              }+                            (makeWordSet True [ "FIXME" , "NOTE" , "TODO" ])+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "JS"+          , Context+              { cName = "JS"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%=?"+                              , reCompiled = Just (compileRegex True "<%=?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "rubysource" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "JS content" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "FindAttributes" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "JS comment close"+          , Context+              { cName = "JS comment close"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</script\\b"+                              , reCompiled = Just (compileRegex False "</script\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "El Close 3" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "JS content"+          , Context+              { cName = "JS content"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%=?"+                              , reCompiled = Just (compileRegex True "<%=?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "rubysource" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</script\\b"+                              , reCompiled = Just (compileRegex False "</script\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "El Close 2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "//(?=.*</script\\b)"+                              , reCompiled = Just (compileRegex False "//(?=.*</script\\b)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "JS comment close" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "JavaScript" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = True+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Line Continue"+          , Context+              { cName = "Line Continue"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(while|until)\\b(?!.*\\bdo\\b)"+                              , reCompiled =+                                  Just (compileRegex True "(while|until)\\b(?!.*\\bdo\\b)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(if|unless)\\b"+                              , reCompiled = Just (compileRegex True "(if|unless)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "rubysource" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Member Access"+          , Context+              { cName = "Member Access"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.?[_a-z]\\w*(\\?|\\!)?(?=[^\\w\\d\\.\\:])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\.?[_a-z]\\w*(\\?|\\!)?(?=[^\\w\\d\\.\\:])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.?[_a-z]\\w*(\\?|\\!)?"+                              , reCompiled = Just (compileRegex True "\\.?[_a-z]\\w*(\\?|\\!)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Z]+_*(\\d|[a-z])\\w*(?=[^\\w\\d\\.\\:])"+                              , reCompiled =+                                  Just+                                    (compileRegex True "[A-Z]+_*(\\d|[a-z])\\w*(?=[^\\w\\d\\.\\:])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Z]+_*([0-9]|[a-z])\\w*"+                              , reCompiled = Just (compileRegex True "[A-Z]+_*([0-9]|[a-z])\\w*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[_A-Z][_A-Z0-9]*(?=[^\\w\\d\\.\\:])"+                              , reCompiled =+                                  Just (compileRegex True "[_A-Z][_A-Z0-9]*(?=[^\\w\\d\\.\\:])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[_A-Z][_A-Z0-9]*"+                              , reCompiled = Just (compileRegex True "[_A-Z][_A-Z0-9]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars ':' ':'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '.'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "=+-*/%|&[]{}~"+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = AnyChar "()\\"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\W"+                              , reCompiled = Just (compileRegex True "\\W")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "PI"+          , Context+              { cName = "PI"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '?' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Quoted String"+          , Context+              { cName = "Quoted String"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "\\\\"+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\\\\""+                              , reCompiled = Just (compileRegex True "\\\\\\\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#@{1,2}"+                              , reCompiled = Just (compileRegex True "#@{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "Short Subst" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "Subst" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RDoc Label"+          , Context+              { cName = "RDoc Label"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules = []+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RegEx 1"+          , Context+              { cName = "RegEx 1"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\\\/"+                              , reCompiled = Just (compileRegex True "\\\\\\/")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^\\\\]$"+                              , reCompiled = Just (compileRegex True "[^\\\\]$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#@{1,2}"+                              , reCompiled = Just (compileRegex True "#@{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "Short Subst" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "Subst" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/[uiomxn]*"+                              , reCompiled = Just (compileRegex True "/[uiomxn]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Short Subst"+          , Context+              { cName = "Short Subst"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#@{1,2}"+                              , reCompiled = Just (compileRegex True "#@{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\w(?!\\w)"+                              , reCompiled = Just (compileRegex True "\\w(?!\\w)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Start"+          , Context+              { cName = "Start"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "FindHTML" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Subst"+          , Context+              { cName = "Subst"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "rubysource" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Value"+          , Context+              { cName = "Value"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%=?"+                              , reCompiled = Just (compileRegex True "<%=?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "rubysource" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "Value DQ" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "Value SQ" ) ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext =+                  [ Push ( "Ruby/Rails/RHTML" , "Value NQ" ) ]+              , cDynamic = False+              }+          )+        , ( "Value DQ"+          , Context+              { cName = "Value DQ"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%=?"+                              , reCompiled = Just (compileRegex True "<%=?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "rubysource" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "FindEntityRefs" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Value NQ"+          , Context+              { cName = "Value NQ"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%=?"+                              , reCompiled = Just (compileRegex True "<%=?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "rubysource" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "FindEntityRefs" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/(?!>)"+                              , reCompiled = Just (compileRegex True "/(?!>)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^/><\"'\\s]"+                              , reCompiled = Just (compileRegex True "[^/><\"'\\s]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop , Pop ]+              , cDynamic = False+              }+          )+        , ( "Value SQ"+          , Context+              { cName = "Value SQ"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<%=?"+                              , reCompiled = Just (compileRegex True "<%=?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "rubysource" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "FindEntityRefs" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "apostrophed_indented_heredoc"+          , Context+              { cName = "apostrophed_indented_heredoc"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1$"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "apostrophed_normal_heredoc"+          , Context+              { cName = "apostrophed_normal_heredoc"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1$"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "apostrophed_rules"+          , Context+              { cName = "apostrophed_rules"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "dq_string_rules"+          , Context+              { cName = "dq_string_rules"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#@{1,2}"+                              , reCompiled = Just (compileRegex True "#@{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "Short Subst" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "Subst" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_gdl_input"+          , Context+              { cName = "find_gdl_input"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "w\\("+                              , reCompiled = Just (compileRegex True "w\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_token_array_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "w\\{"+                              , reCompiled = Just (compileRegex True "w\\{")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_token_array_2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "w\\["+                              , reCompiled = Just (compileRegex True "w\\[")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_token_array_3" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "w<"+                              , reCompiled = Just (compileRegex True "w<")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_token_array_4" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "w([^\\s\\w])"+                              , reCompiled = Just (compileRegex True "w([^\\s\\w])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_token_array_5" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "q\\("+                              , reCompiled = Just (compileRegex True "q\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_apostrophed_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "q\\{"+                              , reCompiled = Just (compileRegex True "q\\{")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_apostrophed_2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "q\\["+                              , reCompiled = Just (compileRegex True "q\\[")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_apostrophed_3" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "q<"+                              , reCompiled = Just (compileRegex True "q<")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_apostrophed_4" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "q([^\\s\\w])"+                              , reCompiled = Just (compileRegex True "q([^\\s\\w])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_apostrophed_5" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "x\\("+                              , reCompiled = Just (compileRegex True "x\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_shell_command_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "x\\{"+                              , reCompiled = Just (compileRegex True "x\\{")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_shell_command_2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "x\\["+                              , reCompiled = Just (compileRegex True "x\\[")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_shell_command_3" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "x<"+                              , reCompiled = Just (compileRegex True "x<")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_shell_command_4" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "x([^\\s\\w])"+                              , reCompiled = Just (compileRegex True "x([^\\s\\w])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_shell_command_5" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "r\\("+                              , reCompiled = Just (compileRegex True "r\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_regexpr_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "r\\{"+                              , reCompiled = Just (compileRegex True "r\\{")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_regexpr_2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "r\\["+                              , reCompiled = Just (compileRegex True "r\\[")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_regexpr_3" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "r<"+                              , reCompiled = Just (compileRegex True "r<")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_regexpr_4" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "r([^\\s\\w])"+                              , reCompiled = Just (compileRegex True "r([^\\s\\w])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_regexpr_5" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "Q?\\("+                              , reCompiled = Just (compileRegex True "Q?\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_dq_string_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "Q?\\{"+                              , reCompiled = Just (compileRegex True "Q?\\{")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_dq_string_2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "Q?\\["+                              , reCompiled = Just (compileRegex True "Q?\\[")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_dq_string_3" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "Q?<"+                              , reCompiled = Just (compileRegex True "Q?<")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_dq_string_4" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "Q?([^\\s\\w])"+                              , reCompiled = Just (compileRegex True "Q?([^\\s\\w])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_dq_string_5" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_heredoc"+          , Context+              { cName = "find_heredoc"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'(\\w+)'"+                              , reCompiled = Just (compileRegex True "'(\\w+)'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "apostrophed_normal_heredoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"?(\\w+)\"?"+                              , reCompiled = Just (compileRegex True "\"?(\\w+)\"?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "normal_heredoc" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_indented_heredoc"+          , Context+              { cName = "find_indented_heredoc"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'(\\w+)'"+                              , reCompiled = Just (compileRegex True "'(\\w+)'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "apostrophed_indented_heredoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"?(\\w+)\"?"+                              , reCompiled = Just (compileRegex True "\"?(\\w+)\"?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "indented_heredoc" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_apostrophed_1"+          , Context+              { cName = "gdl_apostrophed_1"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "apostrophed_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ')'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_apostrophed_1_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_apostrophed_1_nested"+          , Context+              { cName = "gdl_apostrophed_1_nested"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "apostrophed_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_apostrophed_1_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_apostrophed_2"+          , Context+              { cName = "gdl_apostrophed_2"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "apostrophed_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_apostrophed_2_nested" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_apostrophed_2_nested"+          , Context+              { cName = "gdl_apostrophed_2_nested"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "apostrophed_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_apostrophed_2_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_apostrophed_3"+          , Context+              { cName = "gdl_apostrophed_3"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "apostrophed_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ']'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_apostrophed_3_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_apostrophed_3_nested"+          , Context+              { cName = "gdl_apostrophed_3_nested"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "apostrophed_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_apostrophed_3_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_apostrophed_4"+          , Context+              { cName = "gdl_apostrophed_4"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "apostrophed_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '>'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_apostrophed_4_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_apostrophed_4_nested"+          , Context+              { cName = "gdl_apostrophed_4_nested"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "apostrophed_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_apostrophed_4_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_apostrophed_5"+          , Context+              { cName = "gdl_apostrophed_5"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "apostrophed_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "gdl_dq_string_1"+          , Context+              { cName = "gdl_dq_string_1"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "dq_string_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ')'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_dq_string_1_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_dq_string_1_nested"+          , Context+              { cName = "gdl_dq_string_1_nested"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "dq_string_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_dq_string_1_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_dq_string_2"+          , Context+              { cName = "gdl_dq_string_2"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "dq_string_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_dq_string_2_nested" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_dq_string_2_nested"+          , Context+              { cName = "gdl_dq_string_2_nested"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_dq_string_2_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "dq_string_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_dq_string_3"+          , Context+              { cName = "gdl_dq_string_3"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "dq_string_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ']'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_dq_string_3_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_dq_string_3_nested"+          , Context+              { cName = "gdl_dq_string_3_nested"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_dq_string_3_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "dq_string_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_dq_string_4"+          , Context+              { cName = "gdl_dq_string_4"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "dq_string_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '>'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_dq_string_4_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_dq_string_4_nested"+          , Context+              { cName = "gdl_dq_string_4_nested"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_dq_string_4_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "dq_string_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_dq_string_5"+          , Context+              { cName = "gdl_dq_string_5"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "dq_string_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "gdl_regexpr_1"+          , Context+              { cName = "gdl_regexpr_1"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "regexpr_rules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ')'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_regexpr_1_nested" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\)[uiomxn]*"+                              , reCompiled = Just (compileRegex True "\\)[uiomxn]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_regexpr_1_nested"+          , Context+              { cName = "gdl_regexpr_1_nested"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "regexpr_rules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_regexpr_1_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_regexpr_2"+          , Context+              { cName = "gdl_regexpr_2"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "regexpr_rules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\}[uiomxn]*"+                              , reCompiled = Just (compileRegex True "\\}[uiomxn]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_regexpr_2_nested" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_regexpr_2_nested"+          , Context+              { cName = "gdl_regexpr_2_nested"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "regexpr_rules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_regexpr_2_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_regexpr_3"+          , Context+              { cName = "gdl_regexpr_3"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "regexpr_rules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ']'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_regexpr_3_nested" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\][uiomxn]*"+                              , reCompiled = Just (compileRegex True "\\][uiomxn]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_regexpr_3_nested"+          , Context+              { cName = "gdl_regexpr_3_nested"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "regexpr_rules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_regexpr_3_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_regexpr_4"+          , Context+              { cName = "gdl_regexpr_4"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "regexpr_rules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '>'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_regexpr_4_nested" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ">[uiomxn]*"+                              , reCompiled = Just (compileRegex True ">[uiomxn]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_regexpr_4_nested"+          , Context+              { cName = "gdl_regexpr_4_nested"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "regexpr_rules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_regexpr_4_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_regexpr_5"+          , Context+              { cName = "gdl_regexpr_5"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "regexpr_rules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*%1[uiomxn]*"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "gdl_shell_command_1"+          , Context+              { cName = "gdl_shell_command_1"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "shell_command_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ')'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_shell_command_1_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_shell_command_1_nested"+          , Context+              { cName = "gdl_shell_command_1_nested"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "shell_command_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_shell_command_1_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_shell_command_2"+          , Context+              { cName = "gdl_shell_command_2"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "shell_command_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_shell_command_2_nested" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_shell_command_2_nested"+          , Context+              { cName = "gdl_shell_command_2_nested"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "shell_command_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_shell_command_2_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_shell_command_3"+          , Context+              { cName = "gdl_shell_command_3"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "shell_command_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ']'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_shell_command_3_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_shell_command_3_nested"+          , Context+              { cName = "gdl_shell_command_3_nested"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "shell_command_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_shell_command_3_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_shell_command_4"+          , Context+              { cName = "gdl_shell_command_4"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "shell_command_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '>'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_shell_command_4_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_shell_command_4_nested"+          , Context+              { cName = "gdl_shell_command_4_nested"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "shell_command_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_shell_command_4_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_shell_command_5"+          , Context+              { cName = "gdl_shell_command_5"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "shell_command_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "gdl_token_array_1"+          , Context+              { cName = "gdl_token_array_1"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "token_array_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ')'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_token_array_1_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_token_array_1_nested"+          , Context+              { cName = "gdl_token_array_1_nested"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "token_array_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_token_array_1_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_token_array_2"+          , Context+              { cName = "gdl_token_array_2"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "token_array_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_token_array_2_nested" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_token_array_2_nested"+          , Context+              { cName = "gdl_token_array_2_nested"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "token_array_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_token_array_2_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_token_array_3"+          , Context+              { cName = "gdl_token_array_3"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "token_array_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ']'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_token_array_3_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_token_array_3_nested"+          , Context+              { cName = "gdl_token_array_3_nested"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "token_array_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_token_array_3_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_token_array_4"+          , Context+              { cName = "gdl_token_array_4"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "token_array_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '>'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_token_array_4_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_token_array_4_nested"+          , Context+              { cName = "gdl_token_array_4_nested"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "token_array_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "gdl_token_array_4_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_token_array_5"+          , Context+              { cName = "gdl_token_array_5"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          IncludeRules ( "Ruby/Rails/RHTML" , "token_array_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "heredoc_rules"+          , Context+              { cName = "heredoc_rules"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#@{1,2}"+                              , reCompiled = Just (compileRegex True "#@{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "Short Subst" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "Subst" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "indented_heredoc"+          , Context+              { cName = "indented_heredoc"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1$"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "heredoc_rules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "normal_heredoc"+          , Context+              { cName = "normal_heredoc"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1$"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "heredoc_rules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "regexpr_rules"+          , Context+              { cName = "regexpr_rules"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#@{1,2}"+                              , reCompiled = Just (compileRegex True "#@{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "Short Subst" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "Subst" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "rubysource"+          , Context+              { cName = "rubysource"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "Line Continue" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-?%>"+                              , reCompiled = Just (compileRegex True "-?%>")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "__END__$"+                              , reCompiled = Just (compileRegex True "__END__$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "DATA" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#!\\/.*"+                              , reCompiled = Just (compileRegex True "#!\\/.*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\=|\\(|\\[|\\{)\\s*(if|unless|while|until)\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(\\=|\\(|\\[|\\{)\\s*(if|unless|while|until)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(while|until)\\b(?!.*\\bdo\\b)"+                              , reCompiled =+                                  Just (compileRegex True "(while|until)\\b(?!.*\\bdo\\b)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\;\\s*(while|until)\\b(?!.*\\bdo\\b)"+                              , reCompiled =+                                  Just (compileRegex True "\\;\\s*(while|until)\\b(?!.*\\bdo\\b)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(if|unless)\\b"+                              , reCompiled = Just (compileRegex True "(if|unless)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\;\\s*(if|unless)\\b"+                              , reCompiled = Just (compileRegex True "\\;\\s*(if|unless)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bclass\\b"+                              , reCompiled = Just (compileRegex True "\\bclass\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bmodule\\b"+                              , reCompiled = Just (compileRegex True "\\bmodule\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bbegin\\b"+                              , reCompiled = Just (compileRegex True "\\bbegin\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bfor\\b(?!.*\\bdo\\b)"+                              , reCompiled = Just (compileRegex True "\\bfor\\b(?!.*\\bdo\\b)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bcase\\b"+                              , reCompiled = Just (compileRegex True "\\bcase\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bdo\\b"+                              , reCompiled = Just (compileRegex True "\\bdo\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bdef\\b"+                              , reCompiled = Just (compileRegex True "\\bdef\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bend\\b"+                              , reCompiled = Just (compileRegex True "\\bend\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b|^\\s*)(else|elsif|rescue|ensure)(\\s+|$)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(\\b|^\\s*)(else|elsif|rescue|ensure)(\\s+|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "..."+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '.' '.'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.[_a-z][_a-zA-Z0-9]*(\\?|\\!|\\b)"+                              , reCompiled =+                                  Just (compileRegex True "\\.[_a-z][_a-zA-Z0-9]*(\\?|\\!|\\b)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s\\?(\\\\M\\-)?(\\\\C\\-)?\\\\?\\S"+                              , reCompiled =+                                  Just (compileRegex True "\\s\\?(\\\\M\\-)?(\\\\C\\-)?\\\\?\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&()*+,-./:;<=>[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "BEGIN"+                               , "END"+                               , "and"+                               , "begin"+                               , "break"+                               , "case"+                               , "defined?"+                               , "do"+                               , "else"+                               , "elsif"+                               , "end"+                               , "ensure"+                               , "for"+                               , "if"+                               , "in"+                               , "include"+                               , "next"+                               , "not"+                               , "or"+                               , "redo"+                               , "rescue"+                               , "retry"+                               , "return"+                               , "then"+                               , "unless"+                               , "until"+                               , "when"+                               , "while"+                               , "yield"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&()*+,-./:;<=>[\\]^{|}~"+                              }+                            (makeWordSet+                               True [ "attr_accessor" , "attr_reader" , "attr_writer" ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&()*+,-./:;<=>[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "private"+                               , "private_class_method"+                               , "protected"+                               , "public"+                               , "public_class_method"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&()*+,-./:;<=>[\\]^{|}~"+                              }+                            (makeWordSet+                               True [ "alias" , "class" , "def" , "module" , "undef" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&()*+,-./:;<=>[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "__FILE__"+                               , "__LINE__"+                               , "caller"+                               , "false"+                               , "nil"+                               , "self"+                               , "super"+                               , "true"+                               ])+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&()*+,-./:;<=>[\\]^{|}~"+                              }+                            (makeWordSet+                               True [ "$deferr" , "$defout" , "$stderr" , "$stdin" , "$stdout" ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&()*+,-./:;<=>[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "abort"+                               , "at_exit"+                               , "auto_complete_field"+                               , "auto_complete_result"+                               , "auto_discovery_link_tag"+                               , "auto_link"+                               , "autoload"+                               , "autoload?"+                               , "benchmark"+                               , "binding"+                               , "block_given?"+                               , "button_to"+                               , "cache"+                               , "callcc"+                               , "caller"+                               , "capture"+                               , "catch"+                               , "check_box"+                               , "check_box_tag"+                               , "chomp"+                               , "chomp!"+                               , "chop"+                               , "chop!"+                               , "collection_select"+                               , "concat"+                               , "content_for"+                               , "content_tag"+                               , "country_options_for_select"+                               , "country_select"+                               , "current_page?"+                               , "date_select"+                               , "datetime_select"+                               , "debug"+                               , "define_javascript_functions"+                               , "distance_of_time_in_words"+                               , "distance_of_time_in_words_to_now"+                               , "draggable_element"+                               , "drop_receiving_element"+                               , "end_form_tag"+                               , "error_message_on"+                               , "error_messages_for"+                               , "escape_javascript"+                               , "eval"+                               , "evaluate_remote_response"+                               , "excerpt"+                               , "exec"+                               , "exit"+                               , "exit!"+                               , "fail"+                               , "file_field"+                               , "file_field_tag"+                               , "finish_upload_status"+                               , "fork"+                               , "form"+                               , "form_remote_tag"+                               , "form_tag"+                               , "form_tag_with_upload_progress"+                               , "format"+                               , "getc"+                               , "gets"+                               , "global_variables"+                               , "gsub"+                               , "gsub!"+                               , "h"+                               , "hidden_field"+                               , "hidden_field_tag"+                               , "highlight"+                               , "human_size"+                               , "image_path"+                               , "image_submit_tag"+                               , "image_tag"+                               , "input"+                               , "iterator?"+                               , "javascript_include_tag"+                               , "javascript_path"+                               , "javascript_tag"+                               , "lambda"+                               , "link_image_to"+                               , "link_to"+                               , "link_to_function"+                               , "link_to_if"+                               , "link_to_image"+                               , "link_to_remote"+                               , "link_to_unless"+                               , "link_to_unless_current"+                               , "load"+                               , "local_variables"+                               , "loop"+                               , "mail_to"+                               , "markdown"+                               , "method_missing"+                               , "number_to_currency"+                               , "number_to_human_size"+                               , "number_to_percentage"+                               , "number_to_phone"+                               , "number_with_delimiter"+                               , "number_with_precision"+                               , "observe_field"+                               , "observe_form"+                               , "open"+                               , "option_groups_from_collection_for_select"+                               , "options_for_select"+                               , "options_from_collection_for_select"+                               , "p"+                               , "pagination_links"+                               , "password_field"+                               , "password_field_tag"+                               , "periodically_call_remote"+                               , "pluralize"+                               , "print"+                               , "printf"+                               , "proc"+                               , "putc"+                               , "puts"+                               , "radio_button"+                               , "radio_button_tag"+                               , "raise"+                               , "rand"+                               , "readline"+                               , "readlines"+                               , "register_template_handler"+                               , "render"+                               , "render_file"+                               , "render_template"+                               , "require"+                               , "sanitize"+                               , "scan"+                               , "select"+                               , "select_date"+                               , "select_datetime"+                               , "select_day"+                               , "select_hour"+                               , "select_minute"+                               , "select_month"+                               , "select_second"+                               , "select_tag"+                               , "select_time"+                               , "select_year"+                               , "set_trace_func"+                               , "simple_format"+                               , "sleep"+                               , "sortable_element"+                               , "split"+                               , "sprintf"+                               , "srand"+                               , "start_form_tag"+                               , "strip_links"+                               , "stylesheet_link_tag"+                               , "stylesheet_path"+                               , "sub"+                               , "sub!"+                               , "submit_tag"+                               , "submit_to_remote"+                               , "syscall"+                               , "system"+                               , "tag"+                               , "test"+                               , "text_area"+                               , "text_area_tag"+                               , "text_field"+                               , "text_field_tag"+                               , "text_field_with_auto_complete"+                               , "textilize"+                               , "textilize_without_paragraph"+                               , "throw"+                               , "time_ago_in_words"+                               , "time_zone_options_for_select"+                               , "time_zone_select"+                               , "trace_var"+                               , "trap"+                               , "truncate"+                               , "untrace_var"+                               , "update_element_function"+                               , "upload_progress_status"+                               , "upload_progress_text"+                               , "upload_progress_update_bar_js"+                               , "upload_status_progress_bar_tag"+                               , "upload_status_tag"+                               , "upload_status_text_tag"+                               , "url_for"+                               , "visual_effect"+                               , "warn"+                               , "word_wrap"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[a-zA-Z_0-9]+"+                              , reCompiled = Just (compileRegex True "\\$[a-zA-Z_0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\-[a-zA-z_]\\b"+                              , reCompiled = Just (compileRegex True "\\$\\-[a-zA-z_]\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[\\d_*`\\!:?'/\\\\\\-\\&]"+                              , reCompiled =+                                  Just (compileRegex True "\\$[\\d_*`\\!:?'/\\\\\\-\\&]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[_A-Z]+[A-Z_0-9]+\\b"+                              , reCompiled = Just (compileRegex True "\\b[_A-Z]+[A-Z_0-9]+\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[A-Z]+_*([0-9]|[a-z])[_a-zA-Z0-9]*\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex True "\\b[A-Z]+_*([0-9]|[a-z])[_a-zA-Z0-9]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b\\-?0[xX][_0-9a-fA-F]+"+                              , reCompiled = Just (compileRegex True "\\b\\-?0[xX][_0-9a-fA-F]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b\\-?0[bB][_01]+"+                              , reCompiled = Just (compileRegex True "\\b\\-?0[bB][_01]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b\\-?0[1-7][_0-7]*"+                              , reCompiled = Just (compileRegex True "\\b\\-?0[1-7][_0-7]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b\\-?[0-9][0-9_]*\\.[0-9][0-9_]*([eE]\\-?[1-9][0-9]*(\\.[0-9]*)?)?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\b\\-?[0-9][0-9_]*\\.[0-9][0-9_]*([eE]\\-?[1-9][0-9]*(\\.[0-9]*)?)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b\\-?[1-9][0-9_]*\\b"+                              , reCompiled = Just (compileRegex True "\\b\\-?[1-9][0-9_]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "=begin"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "Embedded documentation" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*<<-(?=\\w+|[\"'])"+                              , reCompiled = Just (compileRegex True "\\s*<<-(?=\\w+|[\"'])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "find_indented_heredoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*<<(?=\\w+|[\"'])"+                              , reCompiled = Just (compileRegex True "\\s*<<(?=\\w+|[\"'])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "find_heredoc" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '.'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '&' '&'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '|' '|'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s[\\?\\:\\%/]\\s"+                              , reCompiled = Just (compileRegex True "\\s[\\?\\:\\%/]\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[|&<>\\^\\+*~\\-=]+"+                              , reCompiled = Just (compileRegex True "[|&<>\\^\\+*~\\-=]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s!"+                              , reCompiled = Just (compileRegex True "\\s!")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/=\\s"+                              , reCompiled = Just (compileRegex True "/=\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "%="+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars ':' ':'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "Member Access" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ":[a-zA-Z_][a-zA-Z0-9_]*"+                              , reCompiled = Just (compileRegex True ":[a-zA-Z_][a-zA-Z0-9_]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "Quoted String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "Apostrophed String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "Command String" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "?#"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*BEGIN.*$"+                              , reCompiled = Just (compileRegex True "#\\s*BEGIN.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*END.*$"+                              , reCompiled = Just (compileRegex True "#\\s*END.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#"+                              , reCompiled = Just (compileRegex True "#")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "Comment Line" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s#"+                              , reCompiled = Just (compileRegex True "\\s#")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "General Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\[\\]]+"+                              , reCompiled = Just (compileRegex True "[\\[\\]]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@[a-zA-Z_0-9]+"+                              , reCompiled = Just (compileRegex True "@[a-zA-Z_0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@@[a-zA-Z_0-9]+"+                              , reCompiled = Just (compileRegex True "@@[a-zA-Z_0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '/'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "RegEx 1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*[%](?=[Qqxw]?[^\\s>])"+                              , reCompiled = Just (compileRegex True "\\s*[%](?=[Qqxw]?[^\\s>])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby/Rails/RHTML" , "find_gdl_input" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "rubysourceline"+          , Context+              { cName = "rubysourceline"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby/Rails/RHTML" , "rubysource" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "shell_command_rules"+          , Context+              { cName = "shell_command_rules"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#@{1,2}"+                              , reCompiled = Just (compileRegex True "#@{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "Short Subst" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby/Rails/RHTML" , "Subst" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "token_array_rules"+          , Context+              { cName = "token_array_rules"+              , cSyntax = "Ruby/Rails/RHTML"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "\\\\"+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Richard Dale rdale@foton.es"+  , sVersion = "4"+  , sLicense = "LGPLv2+"+  , sExtensions = [ "*.rhtml" , "*.html.erb" ]+  , sStartingContext = "Start"+  }
+ src/Skylighting/Syntax/Roff.hs view
@@ -0,0 +1,1334 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Roff (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Roff"+  , sFilename = "roff.xml"+  , sShortname = "Roff"+  , sContexts =+      fromList+        [ ( "Argument"+          , Context+              { cName = "Argument"+              , cSyntax = "Roff"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1" , reCompiled = Nothing , reCaseSensitive = True }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Roff" , "DetectOthers" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Roff" , "Error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "Roff"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DetectComments"+          , Context+              { cName = "DetectComments"+              , cSyntax = "Roff"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.\\s*\\\\\""+                              , reCompiled = Just (compileRegex True "\\.\\s*\\\\\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Roff" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '"'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Roff" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Roff" , "Comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DetectDirective"+          , Context+              { cName = "DetectDirective"+              , cSyntax = "Roff"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "br" , "sp" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Roff" , "Directive" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Roff" , "Directive" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Roff" , "Directive" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*ds\\b"+                              , reCompiled = Just (compileRegex True "\\s*ds\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 1+                      , rContextSwitch = [ Push ( "Roff" , "dsDirective" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*de\\b"+                              , reCompiled = Just (compileRegex True "\\s*de\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 1+                      , rContextSwitch = [ Push ( "Roff" , "deDirective" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*da(?=\\s+[A-Za-z]+)"+                              , reCompiled = Just (compileRegex True "\\s*da(?=\\s+[A-Za-z]+)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 1+                      , rContextSwitch = [ Push ( "Roff" , "daDirective" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*di(?=\\s+[A-Za-z]+)"+                              , reCompiled = Just (compileRegex True "\\s*di(?=\\s+[A-Za-z]+)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 1+                      , rContextSwitch = [ Push ( "Roff" , "diDirective" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*[A-Za-z]+\\b"+                              , reCompiled = Just (compileRegex True "\\s*[A-Za-z]+\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 1+                      , rContextSwitch = [ Push ( "Roff" , "Directive" ) ]+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DetectEscape"+          , Context+              { cName = "DetectEscape"+              , cSyntax = "Roff"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\(\\*|n[+-]?)([^]\\s]|\\([^]\\s]{2}|\\[[^]\\s]+\\])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\(\\*|n[+-]?)([^]\\s]|\\([^]\\s]{2}|\\[[^]\\s]+\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[fF]([^]\\s]|\\([^]\\s]{2}|\\[[^]\\s]+\\])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\\\[fF]([^]\\s]|\\([^]\\s]{2}|\\[[^]\\s]+\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\f([0-9]|\\([0-9][0-9]|\\[[0-9]+\\])"+                              , reCompiled =+                                  Just (compileRegex True "\\\\f([0-9]|\\([0-9][0-9]|\\[[0-9]+\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\s(\\[([1-3][0-9]|[04-9])\\]|[04-9]|[+-][0-9]|([+-]?\\(|\\([+-])[0-9][0-9])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\s(\\[([1-3][0-9]|[04-9])\\]|[04-9]|[+-][0-9]|([+-]?\\(|\\([+-])[0-9][0-9])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(\\$[0-9*@]|[.:% |^{}_!?@)/,&:~0acdeEprtu])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\\\(\\$[0-9*@]|[.:% |^{}_!?@)/,&:~0acdeEprtu])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\[ABDXZbow]([^\\\\]|\\\\[% |\\^{}'`\\-!?@)/,&:~0E_acdeprtu])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\[ABDXZbow]([^\\\\]|\\\\[% |\\^{}'`\\-!?@)/,&:~0E_acdeprtu])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Roff" , "Argument" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[gkmMVYz]([^]\\s]|\\([^]\\s]{2}|\\[[^]\\s]+\\])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\\\[gkmMVYz]([^]\\s]|\\([^]\\s]{2}|\\[[^]\\s]+\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\O([0-4]|\\[5[lrci][^]]\\])"+                              , reCompiled =+                                  Just (compileRegex True "\\\\O([0-4]|\\[5[lrci][^]]\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\[hHSvx]([^\\\\]|\\\\[% |\\^{}'`\\-!?@)/,&:~0E_acdeprtu])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\[hHSvx]([^\\\\]|\\\\[% |\\^{}'`\\-!?@)/,&:~0E_acdeprtu])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Roff" , "Measurement" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\[lL]([^\\\\]|\\\\[% |\\^{}'`\\-!?@)/,&:~0E_acdeprtu])\\|?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\[lL]([^\\\\]|\\\\[% |\\^{}'`\\-!?@)/,&:~0E_acdeprtu])\\|?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Roff" , "Measurement" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\R([^\\\\]|\\\\[% |\\^{}'`\\-!?@)/,&:~0E_acdeprtu])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\R([^\\\\]|\\\\[% |\\^{}'`\\-!?@)/,&:~0E_acdeprtu])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Roff" , "Argument" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\\\C([^\\\\]|\\\\[% |\\^{}'`\\-!?@)/,&:~0E_acdeprtu])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\\\C([^\\\\]|\\\\[% |\\^{}'`\\-!?@)/,&:~0E_acdeprtu])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Roff" , "GlyphArgument" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\N([^\\\\0-9]|\\\\[%:{}'`\\-_!@/cep])[0-9]+\\1"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\\\N([^\\\\0-9]|\\\\[%:{}'`\\-_!@/cep])[0-9]+\\1")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\([^]\\s]|\\([^]\\s]{2}|\\[[^]\\s]+\\])"+                              , reCompiled =+                                  Just+                                    (compileRegex True "\\\\([^]\\s]|\\([^]\\s]{2}|\\[[^]\\s]+\\])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\$"+                              , reCompiled = Just (compileRegex True "\\\\$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DetectOthers"+          , Context+              { cName = "DetectOthers"+              , cSyntax = "Roff"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Roff" , "DetectComments" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Roff" , "DetectEscape" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Roff" , "String" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Directive"+          , Context+              { cName = "Directive"+              , cSyntax = "Roff"+              , cRules =+                  [ Rule+                      { rMatcher = Float+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '"'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Roff" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Roff" , "DetectOthers" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Error"+          , Context+              { cName = "Error"+              , cSyntax = "Roff"+              , cRules = []+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "GlyphArgument"+          , Context+              { cName = "GlyphArgument"+              , cSyntax = "Roff"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1" , reCompiled = Nothing , reCaseSensitive = True }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Roff" , "Error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "LiteralIL"+          , Context+              { cName = "LiteralIL"+              , cSyntax = "Roff"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '?'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Roff" , "Error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "LiteralSL"+          , Context+              { cName = "LiteralSL"+              , cSyntax = "Roff"+              , cRules = []+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Measurement"+          , Context+              { cName = "Measurement"+              , cSyntax = "Roff"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1" , reCompiled = Nothing , reCaseSensitive = True }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Roff" , "Error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Roff"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Roff" , "DetectComments" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '.'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Roff" , "DetectDirective" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Roff" , "DetectOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Roff"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '"'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Roff" , "DetectOthers" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "daBody"+          , Context+              { cName = "daBody"+              , cSyntax = "Roff"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.\\s*da\\b"+                              , reCompiled = Just (compileRegex True "\\.\\s*da\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '!'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Roff" , "LiteralSL" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '?'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Roff" , "LiteralIL" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Roff" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "daDirective"+          , Context+              { cName = "daDirective"+              , cSyntax = "Roff"+              , cRules = []+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Roff" , "daBody" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "deBody"+          , Context+              { cName = "deBody"+              , cSyntax = "Roff"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '.' '.'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Roff" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "deDirective"+          , Context+              { cName = "deDirective"+              , cSyntax = "Roff"+              , cRules = []+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Roff" , "deBody" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "diBody"+          , Context+              { cName = "diBody"+              , cSyntax = "Roff"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.\\s*di\\b"+                              , reCompiled = Just (compileRegex True "\\.\\s*di\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '!'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Roff" , "LiteralSL" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '?'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Roff" , "LiteralIL" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Roff" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "diDirective"+          , Context+              { cName = "diDirective"+              , cSyntax = "Roff"+              , cRules = []+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "Roff" , "diBody" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "dsDirective"+          , Context+              { cName = "dsDirective"+              , cSyntax = "Roff"+              , cRules =+                  [ Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '"'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Roff" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Roff" , "dsString" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Roff" , "DetectOthers" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "dsString"+          , Context+              { cName = "dsString"+              , cSyntax = "Roff"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Roff" , "DetectOthers" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Matthew Woehlke (mw_triad@users.sourceforge.net)"+  , sVersion = "2"+  , sLicense = "GPL"+  , sExtensions = []+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Ruby.hs view
@@ -0,0 +1,6225 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Ruby (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Ruby"+  , sFilename = "ruby.xml"+  , sShortname = "Ruby"+  , sContexts =+      fromList+        [ ( "Apostrophed String"+          , Context+              { cName = "Apostrophed String"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "\\\\"+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\\\'"+                              , reCompiled = Just (compileRegex True "\\\\\\'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1_pop" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Command String"+          , Context+              { cName = "Command String"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "\\\\"+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\\\`"+                              , reCompiled = Just (compileRegex True "\\\\\\`")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#@{1,2}"+                              , reCompiled = Just (compileRegex True "#@{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "Short Subst" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "Subst" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1_pop" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment Line"+          , Context+              { cName = "Comment Line"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\w\\:\\:\\s"+                              , reCompiled = Just (compileRegex True "\\w\\:\\:\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "RDoc Label" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "DATA"+          , Context+              { cName = "DATA"+              , cSyntax = "Ruby"+              , cRules = []+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Embedded documentation"+          , Context+              { cName = "Embedded documentation"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "=end(?:\\s.*|$)"+                              , reCompiled = Just (compileRegex True "=end(?:\\s.*|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Find closing block brace"+          , Context+              { cName = "Find closing block brace"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1_pop" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Ruby" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "General Comment"+          , Context+              { cName = "General Comment"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Line Continue"+          , Context+              { cName = "Line Continue"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(while|until)\\b(?!.*\\bdo\\b)"+                              , reCompiled =+                                  Just (compileRegex True "(while|until)\\b(?!.*\\bdo\\b)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(if|unless)\\b"+                              , reCompiled = Just (compileRegex True "(if|unless)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Ruby" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Member Access"+          , Context+              { cName = "Member Access"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.?[_a-z]\\w*(\\?|\\!)?(?=[^\\w\\d\\.\\:])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\.?[_a-z]\\w*(\\?|\\!)?(?=[^\\w\\d\\.\\:])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_2_pop" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.?[_a-z]\\w*(\\?|\\!)?"+                              , reCompiled = Just (compileRegex True "\\.?[_a-z]\\w*(\\?|\\!)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Z]+_*(\\d|[a-z])\\w*(?=[^\\w\\d\\.\\:])"+                              , reCompiled =+                                  Just+                                    (compileRegex True "[A-Z]+_*(\\d|[a-z])\\w*(?=[^\\w\\d\\.\\:])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_2_pop" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Z]+_*([0-9]|[a-z])\\w*"+                              , reCompiled = Just (compileRegex True "[A-Z]+_*([0-9]|[a-z])\\w*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[_A-Z][_A-Z0-9]*(?=[^\\w\\d\\.\\:])"+                              , reCompiled =+                                  Just (compileRegex True "[_A-Z][_A-Z0-9]*(?=[^\\w\\d\\.\\:])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_2_pop" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[_A-Z][_A-Z0-9]*"+                              , reCompiled = Just (compileRegex True "[_A-Z][_A-Z0-9]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars ':' ':'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '.'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "=+-*/%|&[]{}~"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = AnyChar "()\\"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\W"+                              , reCompiled = Just (compileRegex True "\\W")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "Line Continue" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "__END__$"+                              , reCompiled = Just (compileRegex True "__END__$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Ruby" , "DATA" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#!\\/.*"+                              , reCompiled = Just (compileRegex True "#!\\/.*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "Find closing block brace" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\=|\\(|\\[|\\{)\\s*(if|unless|while|until)\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(\\=|\\(|\\[|\\{)\\s*(if|unless|while|until)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(while|until)\\b(?!.*\\bdo\\b)"+                              , reCompiled =+                                  Just (compileRegex True "(while|until)\\b(?!.*\\bdo\\b)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\;\\s*(while|until)\\b(?!.*\\bdo\\b)"+                              , reCompiled =+                                  Just (compileRegex True "\\;\\s*(while|until)\\b(?!.*\\bdo\\b)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(if|unless)\\b"+                              , reCompiled = Just (compileRegex True "(if|unless)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\;\\s*(if|unless)\\b"+                              , reCompiled = Just (compileRegex True "\\;\\s*(if|unless)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bclass\\b"+                              , reCompiled = Just (compileRegex True "\\bclass\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bmodule\\b"+                              , reCompiled = Just (compileRegex True "\\bmodule\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bbegin\\b"+                              , reCompiled = Just (compileRegex True "\\bbegin\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bfor\\b(?!.*\\bdo\\b)"+                              , reCompiled = Just (compileRegex True "\\bfor\\b(?!.*\\bdo\\b)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bcase\\b"+                              , reCompiled = Just (compileRegex True "\\bcase\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bdo\\b"+                              , reCompiled = Just (compileRegex True "\\bdo\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bdef\\b"+                              , reCompiled = Just (compileRegex True "\\bdef\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bend\\b"+                              , reCompiled = Just (compileRegex True "\\bend\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b(else|elsif|rescue|ensure)\\b"+                              , reCompiled =+                                  Just (compileRegex True "\\b(else|elsif|rescue|ensure)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "..."+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '.' '.'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.[_a-z][_a-zA-Z0-9]*(\\?|\\!|\\b)"+                              , reCompiled =+                                  Just (compileRegex True "\\.[_a-z][_a-zA-Z0-9]*(\\?|\\!|\\b)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s\\?(\\\\M\\-)?(\\\\C\\-)?\\\\?\\S"+                              , reCompiled =+                                  Just (compileRegex True "\\s\\?(\\\\M\\-)?(\\\\C\\-)?\\\\?\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&()*+,-./:;<=>[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "BEGIN"+                               , "END"+                               , "and"+                               , "begin"+                               , "break"+                               , "case"+                               , "defined?"+                               , "do"+                               , "else"+                               , "elsif"+                               , "end"+                               , "ensure"+                               , "for"+                               , "if"+                               , "in"+                               , "next"+                               , "not"+                               , "or"+                               , "redo"+                               , "rescue"+                               , "retry"+                               , "return"+                               , "then"+                               , "unless"+                               , "until"+                               , "when"+                               , "yield"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&()*+,-./:;<=>[\\]^{|}~"+                              }+                            (makeWordSet+                               True [ "attr_accessor" , "attr_reader" , "attr_writer" ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&()*+,-./:;<=>[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "private"+                               , "private_class_method"+                               , "protected"+                               , "public"+                               , "public_class_method"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&()*+,-./:;<=>[\\]^{|}~"+                              }+                            (makeWordSet+                               True [ "alias" , "class" , "def" , "module" , "undef" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&()*+,-./:;<=>[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "__FILE__"+                               , "__LINE__"+                               , "caller"+                               , "false"+                               , "nil"+                               , "self"+                               , "super"+                               , "true"+                               ])+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&()*+,-./:;<=>[\\]^{|}~"+                              }+                            (makeWordSet+                               True [ "$deferr" , "$defout" , "$stderr" , "$stdin" , "$stdout" ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&()*+,-./:;<=>[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "abort"+                               , "at_exit"+                               , "autoload"+                               , "autoload?"+                               , "binding"+                               , "block_given?"+                               , "callcc"+                               , "caller"+                               , "catch"+                               , "chomp"+                               , "chomp!"+                               , "chop"+                               , "chop!"+                               , "eval"+                               , "exec"+                               , "exit"+                               , "exit!"+                               , "fail"+                               , "fork"+                               , "format"+                               , "getc"+                               , "gets"+                               , "global_variables"+                               , "gsub"+                               , "gsub!"+                               , "iterator?"+                               , "lambda"+                               , "load"+                               , "local_variables"+                               , "loop"+                               , "method_missing"+                               , "open"+                               , "p"+                               , "print"+                               , "printf"+                               , "proc"+                               , "putc"+                               , "puts"+                               , "raise"+                               , "rand"+                               , "readline"+                               , "readlines"+                               , "require"+                               , "require_relative"+                               , "scan"+                               , "select"+                               , "set_trace_func"+                               , "sleep"+                               , "split"+                               , "sprintf"+                               , "srand"+                               , "sub"+                               , "sub!"+                               , "syscall"+                               , "system"+                               , "test"+                               , "throw"+                               , "trace_var"+                               , "trap"+                               , "untrace_var"+                               , "warn"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&()*+,-./:;<=>[\\]^{|}~"+                              }+                            (makeWordSet True [ "extend" , "include" , "prepend" ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[a-zA-Z_0-9]+"+                              , reCompiled = Just (compileRegex True "\\$[a-zA-Z_0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\-[a-zA-z_]\\b"+                              , reCompiled = Just (compileRegex True "\\$\\-[a-zA-z_]\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[\\d_*`+@;,.~=\\!\\$:?'/\\\\\\-\\&\"><]"+                              , reCompiled =+                                  Just+                                    (compileRegex True "\\$[\\d_*`+@;,.~=\\!\\$:?'/\\\\\\-\\&\"><]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[_A-Z]+[A-Z_0-9]+\\b"+                              , reCompiled = Just (compileRegex True "\\b[_A-Z]+[A-Z_0-9]+\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[A-Z]+_*([0-9]|[a-z])[_a-zA-Z0-9]*\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex True "\\b[A-Z]+_*([0-9]|[a-z])[_a-zA-Z0-9]*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b\\-?0[xX]([0-9a-fA-F]|_[0-9a-fA-F])+"+                              , reCompiled =+                                  Just (compileRegex True "\\b\\-?0[xX]([0-9a-fA-F]|_[0-9a-fA-F])+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b\\-?0[bB]([01]|_[01])+"+                              , reCompiled = Just (compileRegex True "\\b\\-?0[bB]([01]|_[01])+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b\\-?0[1-7]([0-7]|_[0-7])*"+                              , reCompiled =+                                  Just (compileRegex True "\\b\\-?0[1-7]([0-7]|_[0-7])*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b\\-?[0-9]([0-9]|_[0-9])*\\.[0-9]([0-9]|_[0-9])*([eE]\\-?[1-9]([0-9]|_[0-9])*(\\.[0-9]*)?)?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\b\\-?[0-9]([0-9]|_[0-9])*\\.[0-9]([0-9]|_[0-9])*([eE]\\-?[1-9]([0-9]|_[0-9])*(\\.[0-9]*)?)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b\\-?[1-9]([0-9]|_[0-9])*\\b"+                              , reCompiled =+                                  Just (compileRegex True "\\b\\-?[1-9]([0-9]|_[0-9])*\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1" ) ]+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1" ) ]+                      }+                  , Rule+                      { rMatcher = HlCChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "=begin(?:\\s|$)"+                              , reCompiled = Just (compileRegex True "=begin(?:\\s|$)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Ruby" , "Embedded documentation" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*<<-(?=\\w+|[\"'])"+                              , reCompiled = Just (compileRegex True "\\s*<<-(?=\\w+|[\"'])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "find_indented_heredoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*<<(?=\\w+|[\"'])"+                              , reCompiled = Just (compileRegex True "\\s*<<(?=\\w+|[\"'])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "find_heredoc" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '.'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '&' '&'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '|' '|'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s[\\?\\:\\%]\\s"+                              , reCompiled = Just (compileRegex True "\\s[\\?\\:\\%]\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[|&<>\\^\\+*~\\-=]+"+                              , reCompiled = Just (compileRegex True "[|&<>\\^\\+*~\\-=]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s!"+                              , reCompiled = Just (compileRegex True "\\s!")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/=\\s"+                              , reCompiled = Just (compileRegex True "/=\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "%="+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars ':' ':'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "Member Access" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ":(@{1,2}|\\$)?[a-zA-Z_][a-zA-Z0-9_]*[=?!]?"+                              , reCompiled =+                                  Just+                                    (compileRegex True ":(@{1,2}|\\$)?[a-zA-Z_][a-zA-Z0-9_]*[=?!]?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ":\\[\\]=?"+                              , reCompiled = Just (compileRegex True ":\\[\\]=?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(@{1,2}|\\$)?[a-zA-Z_][a-zA-Z0-9_]*[=?!]?: "+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "(@{1,2}|\\$)?[a-zA-Z_][a-zA-Z0-9_]*[=?!]?: ")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[\\]=?: "+                              , reCompiled = Just (compileRegex True "\\[\\]=?: ")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "Quoted String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "Apostrophed String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "Command String" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "?#"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*BEGIN.*$"+                              , reCompiled = Just (compileRegex True "#\\s*BEGIN.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*END.*$"+                              , reCompiled = Just (compileRegex True "#\\s*END.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "General Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@[a-zA-Z_0-9]+"+                              , reCompiled = Just (compileRegex True "@[a-zA-Z_0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@@[a-zA-Z_0-9]+"+                              , reCompiled = Just (compileRegex True "@@[a-zA-Z_0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '/'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "RegEx 1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*[%](?=[QqxwW]?[^\\s])"+                              , reCompiled = Just (compileRegex True "\\s*[%](?=[QqxwW]?[^\\s])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "find_gdl_input" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1" ) ]+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_2" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Quoted String"+          , Context+              { cName = "Quoted String"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "\\\\"+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\\\\""+                              , reCompiled = Just (compileRegex True "\\\\\\\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#@{1,2}"+                              , reCompiled = Just (compileRegex True "#@{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "Short Subst" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "Subst" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1_pop" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RDoc Label"+          , Context+              { cName = "RDoc Label"+              , cSyntax = "Ruby"+              , cRules = []+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RegEx 1"+          , Context+              { cName = "RegEx 1"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\\\/"+                              , reCompiled = Just (compileRegex True "\\\\\\/")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#@{1,2}"+                              , reCompiled = Just (compileRegex True "#@{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "Short Subst" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "Subst" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/[uiomxn]*"+                              , reCompiled = Just (compileRegex True "/[uiomxn]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_1_pop" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Short Subst"+          , Context+              { cName = "Short Subst"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#@{1,2}"+                              , reCompiled = Just (compileRegex True "#@{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\w(?!\\w)"+                              , reCompiled = Just (compileRegex True "\\w(?!\\w)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Subst"+          , Context+              { cName = "Subst"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Ruby" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "apostrophed_indented_heredoc"+          , Context+              { cName = "apostrophed_indented_heredoc"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1$"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "apostrophed_normal_heredoc"+          , Context+              { cName = "apostrophed_normal_heredoc"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1$"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "apostrophed_rules"+          , Context+              { cName = "apostrophed_rules"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "check_div_1"+          , Context+              { cName = "check_div_1"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*"+                              , reCompiled = Just (compileRegex True "\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "/%"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "check_div_1_pop"+          , Context+              { cName = "check_div_1_pop"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*"+                              , reCompiled = Just (compileRegex True "\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "/%"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop , Pop ]+              , cDynamic = False+              }+          )+        , ( "check_div_2"+          , Context+              { cName = "check_div_2"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = AnyChar "/%"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+"+                              , reCompiled = Just (compileRegex True "\\s+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_2_internal" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "check_div_2_internal"+          , Context+              { cName = "check_div_2_internal"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[/%](?=\\s)"+                              , reCompiled = Just (compileRegex True "[/%](?=\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop , Pop ]+              , cDynamic = False+              }+          )+        , ( "check_div_2_pop"+          , Context+              { cName = "check_div_2_pop"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = AnyChar "/%"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+"+                              , reCompiled = Just (compileRegex True "\\s+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "check_div_2_pop_internal" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop , Pop ]+              , cDynamic = False+              }+          )+        , ( "check_div_2_pop_internal"+          , Context+              { cName = "check_div_2_pop_internal"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/(?=\\s)"+                              , reCompiled = Just (compileRegex True "/(?=\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop , Pop , Pop ]+              , cDynamic = False+              }+          )+        , ( "dq_string_rules"+          , Context+              { cName = "dq_string_rules"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#@{1,2}"+                              , reCompiled = Just (compileRegex True "#@{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "Short Subst" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "Subst" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_gdl_input"+          , Context+              { cName = "find_gdl_input"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "w\\("+                              , reCompiled = Just (compileRegex True "w\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_token_array_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "w\\{"+                              , reCompiled = Just (compileRegex True "w\\{")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_token_array_2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "w\\["+                              , reCompiled = Just (compileRegex True "w\\[")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_token_array_3" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "w<"+                              , reCompiled = Just (compileRegex True "w<")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_token_array_4" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "w([^\\s\\w])"+                              , reCompiled = Just (compileRegex True "w([^\\s\\w])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_token_array_5" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "W\\("+                              , reCompiled = Just (compileRegex True "W\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_token_array_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "W\\{"+                              , reCompiled = Just (compileRegex True "W\\{")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_token_array_2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "W\\["+                              , reCompiled = Just (compileRegex True "W\\[")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_token_array_3" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "W<"+                              , reCompiled = Just (compileRegex True "W<")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_token_array_4" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "W([^\\s\\w])"+                              , reCompiled = Just (compileRegex True "W([^\\s\\w])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_token_array_5" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "q\\("+                              , reCompiled = Just (compileRegex True "q\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_apostrophed_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "q\\{"+                              , reCompiled = Just (compileRegex True "q\\{")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_apostrophed_2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "q\\["+                              , reCompiled = Just (compileRegex True "q\\[")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_apostrophed_3" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "q<"+                              , reCompiled = Just (compileRegex True "q<")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_apostrophed_4" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "q([^\\s\\w])"+                              , reCompiled = Just (compileRegex True "q([^\\s\\w])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_apostrophed_5" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "x\\("+                              , reCompiled = Just (compileRegex True "x\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_shell_command_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "x\\{"+                              , reCompiled = Just (compileRegex True "x\\{")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_shell_command_2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "x\\["+                              , reCompiled = Just (compileRegex True "x\\[")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_shell_command_3" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "x<"+                              , reCompiled = Just (compileRegex True "x<")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_shell_command_4" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "x([^\\s\\w])"+                              , reCompiled = Just (compileRegex True "x([^\\s\\w])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_shell_command_5" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "r\\("+                              , reCompiled = Just (compileRegex True "r\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_regexpr_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "r\\{"+                              , reCompiled = Just (compileRegex True "r\\{")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_regexpr_2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "r\\["+                              , reCompiled = Just (compileRegex True "r\\[")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_regexpr_3" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "r<"+                              , reCompiled = Just (compileRegex True "r<")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_regexpr_4" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "r([^\\s\\w])"+                              , reCompiled = Just (compileRegex True "r([^\\s\\w])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_regexpr_5" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "Q?\\("+                              , reCompiled = Just (compileRegex True "Q?\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_dq_string_1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "Q?\\{"+                              , reCompiled = Just (compileRegex True "Q?\\{")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_dq_string_2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "Q?\\["+                              , reCompiled = Just (compileRegex True "Q?\\[")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_dq_string_3" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "Q?<"+                              , reCompiled = Just (compileRegex True "Q?<")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_dq_string_4" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "Q?([^\\s\\w])"+                              , reCompiled = Just (compileRegex True "Q?([^\\s\\w])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_dq_string_5" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_heredoc"+          , Context+              { cName = "find_heredoc"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'(\\w+)'"+                              , reCompiled = Just (compileRegex True "'(\\w+)'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby" , "apostrophed_normal_heredoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"?(\\w+)\"?"+                              , reCompiled = Just (compileRegex True "\"?(\\w+)\"?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "normal_heredoc" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "find_indented_heredoc"+          , Context+              { cName = "find_indented_heredoc"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'(\\w+)'"+                              , reCompiled = Just (compileRegex True "'(\\w+)'")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby" , "apostrophed_indented_heredoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"?(\\w+)\"?"+                              , reCompiled = Just (compileRegex True "\"?(\\w+)\"?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "indented_heredoc" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_apostrophed_1"+          , Context+              { cName = "gdl_apostrophed_1"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "apostrophed_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ')'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_apostrophed_1_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_apostrophed_1_nested"+          , Context+              { cName = "gdl_apostrophed_1_nested"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "apostrophed_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_apostrophed_1_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_apostrophed_2"+          , Context+              { cName = "gdl_apostrophed_2"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "apostrophed_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_apostrophed_2_nested" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_apostrophed_2_nested"+          , Context+              { cName = "gdl_apostrophed_2_nested"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "apostrophed_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_apostrophed_2_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_apostrophed_3"+          , Context+              { cName = "gdl_apostrophed_3"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "apostrophed_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ']'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_apostrophed_3_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_apostrophed_3_nested"+          , Context+              { cName = "gdl_apostrophed_3_nested"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "apostrophed_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_apostrophed_3_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_apostrophed_4"+          , Context+              { cName = "gdl_apostrophed_4"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "apostrophed_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '>'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_apostrophed_4_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_apostrophed_4_nested"+          , Context+              { cName = "gdl_apostrophed_4_nested"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "apostrophed_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_apostrophed_4_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_apostrophed_5"+          , Context+              { cName = "gdl_apostrophed_5"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "apostrophed_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "gdl_dq_string_1"+          , Context+              { cName = "gdl_dq_string_1"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "dq_string_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ')'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_dq_string_1_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_dq_string_1_nested"+          , Context+              { cName = "gdl_dq_string_1_nested"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "dq_string_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_dq_string_1_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_dq_string_2"+          , Context+              { cName = "gdl_dq_string_2"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "dq_string_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_dq_string_2_nested" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_dq_string_2_nested"+          , Context+              { cName = "gdl_dq_string_2_nested"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_dq_string_2_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Ruby" , "dq_string_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_dq_string_3"+          , Context+              { cName = "gdl_dq_string_3"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "dq_string_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ']'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_dq_string_3_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_dq_string_3_nested"+          , Context+              { cName = "gdl_dq_string_3_nested"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_dq_string_3_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Ruby" , "dq_string_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_dq_string_4"+          , Context+              { cName = "gdl_dq_string_4"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "dq_string_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '>'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_dq_string_4_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_dq_string_4_nested"+          , Context+              { cName = "gdl_dq_string_4_nested"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_dq_string_4_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Ruby" , "dq_string_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_dq_string_5"+          , Context+              { cName = "gdl_dq_string_5"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "dq_string_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "gdl_regexpr_1"+          , Context+              { cName = "gdl_regexpr_1"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "regexpr_rules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ')'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_regexpr_1_nested" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\)[uiomxn]*"+                              , reCompiled = Just (compileRegex True "\\)[uiomxn]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_regexpr_1_nested"+          , Context+              { cName = "gdl_regexpr_1_nested"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "regexpr_rules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_regexpr_1_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_regexpr_2"+          , Context+              { cName = "gdl_regexpr_2"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "regexpr_rules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\}[uiomxn]*"+                              , reCompiled = Just (compileRegex True "\\}[uiomxn]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_regexpr_2_nested" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_regexpr_2_nested"+          , Context+              { cName = "gdl_regexpr_2_nested"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "regexpr_rules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_regexpr_2_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_regexpr_3"+          , Context+              { cName = "gdl_regexpr_3"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "regexpr_rules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ']'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_regexpr_3_nested" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\][uiomxn]*"+                              , reCompiled = Just (compileRegex True "\\][uiomxn]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_regexpr_3_nested"+          , Context+              { cName = "gdl_regexpr_3_nested"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "regexpr_rules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_regexpr_3_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_regexpr_4"+          , Context+              { cName = "gdl_regexpr_4"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "regexpr_rules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '>'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_regexpr_4_nested" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ">[uiomxn]*"+                              , reCompiled = Just (compileRegex True ">[uiomxn]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_regexpr_4_nested"+          , Context+              { cName = "gdl_regexpr_4_nested"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "regexpr_rules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_regexpr_4_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_regexpr_5"+          , Context+              { cName = "gdl_regexpr_5"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "regexpr_rules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*%1[uiomxn]*"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "gdl_shell_command_1"+          , Context+              { cName = "gdl_shell_command_1"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "shell_command_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ')'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby" , "gdl_shell_command_1_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_shell_command_1_nested"+          , Context+              { cName = "gdl_shell_command_1_nested"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "shell_command_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby" , "gdl_shell_command_1_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_shell_command_2"+          , Context+              { cName = "gdl_shell_command_2"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "shell_command_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby" , "gdl_shell_command_2_nested" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_shell_command_2_nested"+          , Context+              { cName = "gdl_shell_command_2_nested"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "shell_command_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby" , "gdl_shell_command_2_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_shell_command_3"+          , Context+              { cName = "gdl_shell_command_3"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "shell_command_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ']'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby" , "gdl_shell_command_3_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_shell_command_3_nested"+          , Context+              { cName = "gdl_shell_command_3_nested"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "shell_command_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby" , "gdl_shell_command_3_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_shell_command_4"+          , Context+              { cName = "gdl_shell_command_4"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "shell_command_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '>'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby" , "gdl_shell_command_4_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_shell_command_4_nested"+          , Context+              { cName = "gdl_shell_command_4_nested"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "shell_command_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Ruby" , "gdl_shell_command_4_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_shell_command_5"+          , Context+              { cName = "gdl_shell_command_5"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "shell_command_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "gdl_token_array_1"+          , Context+              { cName = "gdl_token_array_1"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "token_array_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ')'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_token_array_1_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_token_array_1_nested"+          , Context+              { cName = "gdl_token_array_1_nested"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "token_array_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_token_array_1_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_token_array_2"+          , Context+              { cName = "gdl_token_array_2"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "token_array_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_token_array_2_nested" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_token_array_2_nested"+          , Context+              { cName = "gdl_token_array_2_nested"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "token_array_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_token_array_2_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_token_array_3"+          , Context+              { cName = "gdl_token_array_3"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "token_array_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ']'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_token_array_3_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_token_array_3_nested"+          , Context+              { cName = "gdl_token_array_3_nested"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "token_array_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_token_array_3_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_token_array_4"+          , Context+              { cName = "gdl_token_array_4"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "token_array_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '>'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_token_array_4_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_token_array_4_nested"+          , Context+              { cName = "gdl_token_array_4_nested"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "token_array_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "gdl_token_array_4_nested" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "gdl_token_array_5"+          , Context+              { cName = "gdl_token_array_5"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Ruby" , "token_array_rules" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "heredoc_rules"+          , Context+              { cName = "heredoc_rules"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#@{1,2}"+                              , reCompiled = Just (compileRegex True "#@{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "Short Subst" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "Subst" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "indented_heredoc"+          , Context+              { cName = "indented_heredoc"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1$"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Ruby" , "heredoc_rules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "normal_heredoc"+          , Context+              { cName = "normal_heredoc"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1$"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Ruby" , "heredoc_rules" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "regexpr_rules"+          , Context+              { cName = "regexpr_rules"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#@{1,2}"+                              , reCompiled = Just (compileRegex True "#@{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "Short Subst" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "Subst" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "shell_command_rules"+          , Context+              { cName = "shell_command_rules"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#@{1,2}"+                              , reCompiled = Just (compileRegex True "#@{1,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "Short Subst" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Ruby" , "Subst" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "token_array_rules"+          , Context+              { cName = "token_array_rules"+              , cSyntax = "Ruby"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "\\\\"+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor =+      "Stefan Lang (langstefan@gmx.at), Sebastian Vuorinen (sebastian.vuorinen@helsinki.fi), Robin Pedersen (robinpeder@gmail.com), Miquel Sabat\233 (mikisabate@gmail.com)"+  , sVersion = "3"+  , sLicense = "LGPLv2+"+  , sExtensions =+      [ "*.rb"+      , "*.rjs"+      , "*.rxml"+      , "*.xml.erb"+      , "*.js.erb"+      , "*.rake"+      , "Rakefile"+      , "Gemfile"+      , "*.gemspec"+      , "Vagrantfile"+      ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Rust.hs view
@@ -0,0 +1,1236 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Rust (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Rust"+  , sFilename = "rust.xml"+  , sShortname = "Rust"+  , sContexts =+      fromList+        [ ( "Attribute"+          , Context+              { cName = "Attribute"+              , cSyntax = "Rust"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Rust" , "Normal" )+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = AttributeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CharEscape"+          , Context+              { cName = "CharEscape"+              , cSyntax = "Rust"+              , cRules =+                  [ Rule+                      { rMatcher = AnyChar "nrt\\'\""+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "x[0-9a-fA-F]{2}"+                              , reCompiled = Just (compileRegex True "x[0-9a-fA-F]{2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "u\\{[0-9a-fA-F]{1,6}\\}"+                              , reCompiled = Just (compileRegex True "u\\{[0-9a-fA-F]{1,6}\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "u[0-9a-fA-F]{4}"+                              , reCompiled = Just (compileRegex True "u[0-9a-fA-F]{4}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "U[0-9a-fA-F]{8}"+                              , reCompiled = Just (compileRegex True "U[0-9a-fA-F]{8}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = SpecialCharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Character"+          , Context+              { cName = "Character"+              , cSyntax = "Rust"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Rust" , "CharEscape" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Commentar 1"+          , Context+              { cName = "Commentar 1"+              , cSyntax = "Rust"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Commentar 2"+          , Context+              { cName = "Commentar 2"+              , cSyntax = "Rust"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Rust" , "Commentar 2" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Function"+          , Context+              { cName = "Function"+              , cSyntax = "Rust"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Rust"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "fn" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Rust" , "Function" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "type" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Rust" , "Type" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Self"+                               , "abstract"+                               , "alignof"+                               , "as"+                               , "become"+                               , "box"+                               , "break"+                               , "const"+                               , "continue"+                               , "crate"+                               , "do"+                               , "else"+                               , "enum"+                               , "extern"+                               , "final"+                               , "for"+                               , "if"+                               , "impl"+                               , "in"+                               , "let"+                               , "loop"+                               , "macro"+                               , "match"+                               , "mod"+                               , "move"+                               , "mut"+                               , "offsetof"+                               , "override"+                               , "priv"+                               , "proc"+                               , "pub"+                               , "pure"+                               , "ref"+                               , "return"+                               , "self"+                               , "sizeof"+                               , "static"+                               , "struct"+                               , "super"+                               , "trait"+                               , "type"+                               , "typeof"+                               , "unsafe"+                               , "unsized"+                               , "use"+                               , "virtual"+                               , "where"+                               , "while"+                               , "yield"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Box"+                               , "Option"+                               , "Result"+                               , "Self"+                               , "String"+                               , "Vec"+                               , "bool"+                               , "char"+                               , "f32"+                               , "f64"+                               , "float"+                               , "i16"+                               , "i32"+                               , "i64"+                               , "i8"+                               , "int"+                               , "isize"+                               , "str"+                               , "u16"+                               , "u32"+                               , "u64"+                               , "u8"+                               , "uint"+                               , "usize"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "AsSlice"+                               , "CharExt"+                               , "Clone"+                               , "Copy"+                               , "Debug"+                               , "Decodable"+                               , "Default"+                               , "Display"+                               , "DoubleEndedIterator"+                               , "Drop"+                               , "Encodable"+                               , "Eq"+                               , "Extend"+                               , "Fn"+                               , "FnMut"+                               , "FnOnce"+                               , "FromPrimitive"+                               , "Hash"+                               , "Iterator"+                               , "IteratorExt"+                               , "MutPtrExt"+                               , "Ord"+                               , "PartialEq"+                               , "PartialOrd"+                               , "PtrExt"+                               , "Rand"+                               , "Send"+                               , "Sized"+                               , "SliceConcatExt"+                               , "SliceExt"+                               , "Str"+                               , "StrExt"+                               , "Sync"+                               , "ToString"+                               ])+                      , rAttribute = BuiltInTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "DIR"+                               , "FILE"+                               , "c_char"+                               , "c_double"+                               , "c_float"+                               , "c_int"+                               , "c_long"+                               , "c_longlong"+                               , "c_schar"+                               , "c_short"+                               , "c_uchar"+                               , "c_uint"+                               , "c_ulong"+                               , "c_ulonglong"+                               , "c_ushort"+                               , "c_void"+                               , "clock_t"+                               , "dev_t"+                               , "dirent"+                               , "fpos_t"+                               , "ino_t"+                               , "intptr_t"+                               , "mode_t"+                               , "off_t"+                               , "pid_t"+                               , "ptrdiff_t"+                               , "size_t"+                               , "ssize_t"+                               , "time_t"+                               , "uintptr_t"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "self" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Cons"+                               , "Err"+                               , "Failure"+                               , "Nil"+                               , "None"+                               , "Ok"+                               , "Some"+                               , "Success"+                               , "false"+                               , "true"+                               ])+                      , rAttribute = ConstantTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "BUFSIZ"+                               , "EOF"+                               , "EXIT_FAILURE"+                               , "EXIT_SUCCESS"+                               , "FILENAME_MAX"+                               , "FOPEN_MAX"+                               , "F_OK"+                               , "L_tmpnam"+                               , "O_APPEND"+                               , "O_CREAT"+                               , "O_EXCL"+                               , "O_RDONLY"+                               , "O_RDWR"+                               , "O_TRUNC"+                               , "O_WRONLY"+                               , "RAND_MAX"+                               , "R_OK"+                               , "SEEK_CUR"+                               , "SEEK_END"+                               , "SEEK_SET"+                               , "STDERR_FILENO"+                               , "STDIN_FILENO"+                               , "STDOUT_FILENO"+                               , "S_IEXEC"+                               , "S_IFBLK"+                               , "S_IFCHR"+                               , "S_IFDIR"+                               , "S_IFIFO"+                               , "S_IFMT"+                               , "S_IFREG"+                               , "S_IREAD"+                               , "S_IRUSR"+                               , "S_IRWXU"+                               , "S_IWRITE"+                               , "S_IWUSR"+                               , "S_IXUSR"+                               , "TMP_MAX"+                               , "W_OK"+                               , "X_OK"+                               , "_IOFBF"+                               , "_IOLBF"+                               , "_IONBF"+                               ])+                      , rAttribute = ConstantTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Rust" , "Commentar 1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Rust" , "Commentar 2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "0x[0-9a-fA-F_]+([iu](8|16|32|64)?)?"+                              , reCompiled =+                                  Just (compileRegex True "0x[0-9a-fA-F_]+([iu](8|16|32|64)?)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "0o[0-7_]+([iu](8|16|32|64)?)?"+                              , reCompiled =+                                  Just (compileRegex True "0o[0-7_]+([iu](8|16|32|64)?)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "0b[0-1_]+([iu](8|16|32|64)?)?"+                              , reCompiled =+                                  Just (compileRegex True "0b[0-1_]+([iu](8|16|32|64)?)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "[0-9][0-9_]*\\.[0-9_]*([eE][+-]?[0-9_]+)?(f32|f64|f)?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "[0-9][0-9_]*\\.[0-9_]*([eE][+-]?[0-9_]+)?(f32|f64|f)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[0-9][0-9_]*([iu](8|16|32|64)?)?"+                              , reCompiled =+                                  Just (compileRegex True "[0-9][0-9_]*([iu](8|16|32|64)?)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '['+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Rust" , "Attribute" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "#!["+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Rust" , "Attribute" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z_][a-zA-Z_0-9]*::"+                              , reCompiled = Just (compileRegex True "[a-zA-Z_][a-zA-Z_0-9]*::")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z_][a-zA-Z_0-9]*!"+                              , reCompiled = Just (compileRegex True "[a-zA-Z_][a-zA-Z_0-9]*!")+                              , reCaseSensitive = True+                              }+                      , rAttribute = PreprocessorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "'[a-zA-Z_][a-zA-Z_0-9]*(?!')"+                              , reCompiled =+                                  Just (compileRegex True "'[a-zA-Z_][a-zA-Z_0-9]*(?!')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars 'r' '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Rust" , "RawString" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "r##\""+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Rust" , "RawHashed2" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "r#\""+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Rust" , "RawHashed1" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Rust" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Rust" , "Character" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = OperatorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RawHashed1"+          , Context+              { cName = "RawHashed1"+              , cSyntax = "Rust"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '"' '#'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RawHashed2"+          , Context+              { cName = "RawHashed2"+              , cSyntax = "Rust"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "\"##"+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "RawString"+          , Context+              { cName = "RawString"+              , cSyntax = "Rust"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Rust"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = SpecialCharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Rust" , "CharEscape" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Type"+          , Context+              { cName = "Type"+              , cSyntax = "Rust"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "The Rust Project Developers"+  , sVersion = "4"+  , sLicense = "MIT"+  , sExtensions = [ "*.rs" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Scala.hs view
@@ -0,0 +1,4037 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Scala (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Scala"+  , sFilename = "scala.xml"+  , sShortname = "Scala"+  , sContexts =+      fromList+        [ ( "Commentar 1"+          , Context+              { cName = "Commentar 1"+              , cSyntax = "Scala"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Commentar 2"+          , Context+              { cName = "Commentar 2"+              , cSyntax = "Scala"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Member"+          , Context+              { cName = "Member"+              , cSyntax = "Scala"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[_a-zA-Z]\\w*(?=[\\s]*)"+                              , reCompiled =+                                  Just (compileRegex True "\\b[_a-zA-Z]\\w*(?=[\\s]*)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Scala"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Javadoc" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "abstract"+                               , "case"+                               , "catch"+                               , "class"+                               , "def"+                               , "do"+                               , "else"+                               , "extends"+                               , "false"+                               , "final"+                               , "finally"+                               , "for"+                               , "forSome"+                               , "if"+                               , "implicit"+                               , "import"+                               , "lazy"+                               , "match"+                               , "new"+                               , "null"+                               , "object"+                               , "override"+                               , "package"+                               , "private"+                               , "protected"+                               , "requires"+                               , "return"+                               , "sealed"+                               , "super"+                               , "this"+                               , "throw"+                               , "trait"+                               , "true"+                               , "try"+                               , "type"+                               , "val"+                               , "var"+                               , "while"+                               , "with"+                               , "yield"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "boolean"+                               , "byte"+                               , "char"+                               , "double"+                               , "float"+                               , "int"+                               , "long"+                               , "short"+                               , "unit"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "ACTIVE"+                               , "ACTIVITY_COMPLETED"+                               , "ACTIVITY_REQUIRED"+                               , "ARG_IN"+                               , "ARG_INOUT"+                               , "ARG_OUT"+                               , "AWTError"+                               , "AWTEvent"+                               , "AWTEventListener"+                               , "AWTEventListenerProxy"+                               , "AWTEventMulticaster"+                               , "AWTException"+                               , "AWTKeyStroke"+                               , "AWTPermission"+                               , "AbstractAction"+                               , "AbstractBorder"+                               , "AbstractButton"+                               , "AbstractCellEditor"+                               , "AbstractCollection"+                               , "AbstractColorChooserPanel"+                               , "AbstractDocument"+                               , "AbstractDocument.AttributeContext"+                               , "AbstractDocument.Content"+                               , "AbstractDocument.ElementEdit"+                               , "AbstractExecutorService"+                               , "AbstractInterruptibleChannel"+                               , "AbstractLayoutCache"+                               , "AbstractLayoutCache.NodeDimensions"+                               , "AbstractList"+                               , "AbstractListModel"+                               , "AbstractMap"+                               , "AbstractMethodError"+                               , "AbstractPreferences"+                               , "AbstractQueue"+                               , "AbstractQueuedSynchronizer"+                               , "AbstractSelectableChannel"+                               , "AbstractSelectionKey"+                               , "AbstractSelector"+                               , "AbstractSequentialList"+                               , "AbstractSet"+                               , "AbstractSpinnerModel"+                               , "AbstractTableModel"+                               , "AbstractUndoableEdit"+                               , "AbstractWriter"+                               , "AccessControlContext"+                               , "AccessControlException"+                               , "AccessController"+                               , "AccessException"+                               , "Accessible"+                               , "AccessibleAction"+                               , "AccessibleAttributeSequence"+                               , "AccessibleBundle"+                               , "AccessibleComponent"+                               , "AccessibleContext"+                               , "AccessibleEditableText"+                               , "AccessibleExtendedComponent"+                               , "AccessibleExtendedTable"+                               , "AccessibleExtendedText"+                               , "AccessibleHyperlink"+                               , "AccessibleHypertext"+                               , "AccessibleIcon"+                               , "AccessibleKeyBinding"+                               , "AccessibleObject"+                               , "AccessibleRelation"+                               , "AccessibleRelationSet"+                               , "AccessibleResourceBundle"+                               , "AccessibleRole"+                               , "AccessibleSelection"+                               , "AccessibleState"+                               , "AccessibleStateSet"+                               , "AccessibleStreamable"+                               , "AccessibleTable"+                               , "AccessibleTableModelChange"+                               , "AccessibleText"+                               , "AccessibleTextSequence"+                               , "AccessibleValue"+                               , "AccountException"+                               , "AccountExpiredException"+                               , "AccountLockedException"+                               , "AccountNotFoundException"+                               , "Acl"+                               , "AclEntry"+                               , "AclNotFoundException"+                               , "Action"+                               , "ActionEvent"+                               , "ActionListener"+                               , "ActionMap"+                               , "ActionMapUIResource"+                               , "Activatable"+                               , "ActivateFailedException"+                               , "ActivationDesc"+                               , "ActivationException"+                               , "ActivationGroup"+                               , "ActivationGroupDesc"+                               , "ActivationGroupDesc.CommandEnvironment"+                               , "ActivationGroupID"+                               , "ActivationGroup_Stub"+                               , "ActivationID"+                               , "ActivationInstantiator"+                               , "ActivationMonitor"+                               , "ActivationSystem"+                               , "Activator"+                               , "ActiveEvent"+                               , "ActivityCompletedException"+                               , "ActivityRequiredException"+                               , "AdapterActivator"+                               , "AdapterActivatorOperations"+                               , "AdapterAlreadyExists"+                               , "AdapterAlreadyExistsHelper"+                               , "AdapterInactive"+                               , "AdapterInactiveHelper"+                               , "AdapterManagerIdHelper"+                               , "AdapterNameHelper"+                               , "AdapterNonExistent"+                               , "AdapterNonExistentHelper"+                               , "AdapterStateHelper"+                               , "AddressHelper"+                               , "Adjustable"+                               , "AdjustmentEvent"+                               , "AdjustmentListener"+                               , "Adler32"+                               , "AffineTransform"+                               , "AffineTransformOp"+                               , "AlgorithmParameterGenerator"+                               , "AlgorithmParameterGeneratorSpi"+                               , "AlgorithmParameterSpec"+                               , "AlgorithmParameters"+                               , "AlgorithmParametersSpi"+                               , "AllPermission"+                               , "AlphaComposite"+                               , "AlreadyBound"+                               , "AlreadyBoundException"+                               , "AlreadyBoundHelper"+                               , "AlreadyBoundHolder"+                               , "AlreadyConnectedException"+                               , "AncestorEvent"+                               , "AncestorListener"+                               , "AnnotatedElement"+                               , "Annotation"+                               , "AnnotationFormatError"+                               , "AnnotationTypeMismatchException"+                               , "Any"+                               , "AnyHolder"+                               , "AnySeqHelper"+                               , "AnySeqHolder"+                               , "AppConfigurationEntry"+                               , "AppConfigurationEntry.LoginModuleControlFlag"+                               , "Appendable"+                               , "Applet"+                               , "AppletContext"+                               , "AppletInitializer"+                               , "AppletStub"+                               , "ApplicationException"+                               , "Arc2D"+                               , "Arc2D.Double"+                               , "Arc2D.Float"+                               , "Area"+                               , "AreaAveragingScaleFilter"+                               , "ArithmeticException"+                               , "Array"+                               , "ArrayBlockingQueue"+                               , "ArrayIndexOutOfBoundsException"+                               , "ArrayList"+                               , "ArrayStoreException"+                               , "ArrayType"+                               , "Arrays"+                               , "AssertionError"+                               , "AsyncBoxView"+                               , "AsynchronousCloseException"+                               , "AtomicBoolean"+                               , "AtomicInteger"+                               , "AtomicIntegerArray"+                               , "AtomicIntegerFieldUpdater"+                               , "AtomicLong"+                               , "AtomicLongArray"+                               , "AtomicLongFieldUpdater"+                               , "AtomicMarkableReference"+                               , "AtomicReference"+                               , "AtomicReferenceArray"+                               , "AtomicReferenceFieldUpdater"+                               , "AtomicStampedReference"+                               , "Attr"+                               , "Attribute"+                               , "AttributeChangeNotification"+                               , "AttributeChangeNotificationFilter"+                               , "AttributeException"+                               , "AttributeInUseException"+                               , "AttributeList"+                               , "AttributeListImpl"+                               , "AttributeModificationException"+                               , "AttributeNotFoundException"+                               , "AttributeSet"+                               , "AttributeSet.CharacterAttribute"+                               , "AttributeSet.ColorAttribute"+                               , "AttributeSet.FontAttribute"+                               , "AttributeSet.ParagraphAttribute"+                               , "AttributeSetUtilities"+                               , "AttributeValueExp"+                               , "AttributedCharacterIterator"+                               , "AttributedCharacterIterator.Attribute"+                               , "AttributedString"+                               , "Attributes"+                               , "Attributes.Name"+                               , "Attributes2"+                               , "Attributes2Impl"+                               , "AttributesImpl"+                               , "AudioClip"+                               , "AudioFileFormat"+                               , "AudioFileFormat.Type"+                               , "AudioFileReader"+                               , "AudioFileWriter"+                               , "AudioFormat"+                               , "AudioFormat.Encoding"+                               , "AudioInputStream"+                               , "AudioPermission"+                               , "AudioSystem"+                               , "AuthPermission"+                               , "AuthProvider"+                               , "AuthenticationException"+                               , "AuthenticationNotSupportedException"+                               , "Authenticator"+                               , "Authenticator.RequestorType"+                               , "AuthorizeCallback"+                               , "Autoscroll"+                               , "BAD_CONTEXT"+                               , "BAD_INV_ORDER"+                               , "BAD_OPERATION"+                               , "BAD_PARAM"+                               , "BAD_POLICY"+                               , "BAD_POLICY_TYPE"+                               , "BAD_POLICY_VALUE"+                               , "BAD_QOS"+                               , "BAD_TYPECODE"+                               , "BMPImageWriteParam"+                               , "BackingStoreException"+                               , "BadAttributeValueExpException"+                               , "BadBinaryOpValueExpException"+                               , "BadKind"+                               , "BadLocationException"+                               , "BadPaddingException"+                               , "BadStringOperationException"+                               , "BandCombineOp"+                               , "BandedSampleModel"+                               , "BaseRowSet"+                               , "BasicArrowButton"+                               , "BasicAttribute"+                               , "BasicAttributes"+                               , "BasicBorders"+                               , "BasicBorders.ButtonBorder"+                               , "BasicBorders.FieldBorder"+                               , "BasicBorders.MarginBorder"+                               , "BasicBorders.MenuBarBorder"+                               , "BasicBorders.RadioButtonBorder"+                               , "BasicBorders.RolloverButtonBorder"+                               , "BasicBorders.SplitPaneBorder"+                               , "BasicBorders.ToggleButtonBorder"+                               , "BasicButtonListener"+                               , "BasicButtonUI"+                               , "BasicCheckBoxMenuItemUI"+                               , "BasicCheckBoxUI"+                               , "BasicColorChooserUI"+                               , "BasicComboBoxEditor"+                               , "BasicComboBoxEditor.UIResource"+                               , "BasicComboBoxRenderer"+                               , "BasicComboBoxRenderer.UIResource"+                               , "BasicComboBoxUI"+                               , "BasicComboPopup"+                               , "BasicControl"+                               , "BasicDesktopIconUI"+                               , "BasicDesktopPaneUI"+                               , "BasicDirectoryModel"+                               , "BasicEditorPaneUI"+                               , "BasicFileChooserUI"+                               , "BasicFormattedTextFieldUI"+                               , "BasicGraphicsUtils"+                               , "BasicHTML"+                               , "BasicIconFactory"+                               , "BasicInternalFrameTitlePane"+                               , "BasicInternalFrameUI"+                               , "BasicLabelUI"+                               , "BasicListUI"+                               , "BasicLookAndFeel"+                               , "BasicMenuBarUI"+                               , "BasicMenuItemUI"+                               , "BasicMenuUI"+                               , "BasicOptionPaneUI"+                               , "BasicOptionPaneUI.ButtonAreaLayout"+                               , "BasicPanelUI"+                               , "BasicPasswordFieldUI"+                               , "BasicPermission"+                               , "BasicPopupMenuSeparatorUI"+                               , "BasicPopupMenuUI"+                               , "BasicProgressBarUI"+                               , "BasicRadioButtonMenuItemUI"+                               , "BasicRadioButtonUI"+                               , "BasicRootPaneUI"+                               , "BasicScrollBarUI"+                               , "BasicScrollPaneUI"+                               , "BasicSeparatorUI"+                               , "BasicSliderUI"+                               , "BasicSpinnerUI"+                               , "BasicSplitPaneDivider"+                               , "BasicSplitPaneUI"+                               , "BasicStroke"+                               , "BasicTabbedPaneUI"+                               , "BasicTableHeaderUI"+                               , "BasicTableUI"+                               , "BasicTextAreaUI"+                               , "BasicTextFieldUI"+                               , "BasicTextPaneUI"+                               , "BasicTextUI"+                               , "BasicTextUI.BasicCaret"+                               , "BasicTextUI.BasicHighlighter"+                               , "BasicToggleButtonUI"+                               , "BasicToolBarSeparatorUI"+                               , "BasicToolBarUI"+                               , "BasicToolTipUI"+                               , "BasicTreeUI"+                               , "BasicViewportUI"+                               , "BatchUpdateException"+                               , "BeanContext"+                               , "BeanContextChild"+                               , "BeanContextChildComponentProxy"+                               , "BeanContextChildSupport"+                               , "BeanContextContainerProxy"+                               , "BeanContextEvent"+                               , "BeanContextMembershipEvent"+                               , "BeanContextMembershipListener"+                               , "BeanContextProxy"+                               , "BeanContextServiceAvailableEvent"+                               , "BeanContextServiceProvider"+                               , "BeanContextServiceProviderBeanInfo"+                               , "BeanContextServiceRevokedEvent"+                               , "BeanContextServiceRevokedListener"+                               , "BeanContextServices"+                               , "BeanContextServicesListener"+                               , "BeanContextServicesSupport"+                               , "BeanContextServicesSupport.BCSSServiceProvider"+                               , "BeanContextSupport"+                               , "BeanContextSupport.BCSIterator"+                               , "BeanDescriptor"+                               , "BeanInfo"+                               , "Beans"+                               , "BevelBorder"+                               , "Bidi"+                               , "BigDecimal"+                               , "BigInteger"+                               , "BinaryRefAddr"+                               , "BindException"+                               , "Binding"+                               , "BindingHelper"+                               , "BindingHolder"+                               , "BindingIterator"+                               , "BindingIteratorHelper"+                               , "BindingIteratorHolder"+                               , "BindingIteratorOperations"+                               , "BindingIteratorPOA"+                               , "BindingListHelper"+                               , "BindingListHolder"+                               , "BindingType"+                               , "BindingTypeHelper"+                               , "BindingTypeHolder"+                               , "BitSet"+                               , "Blob"+                               , "BlockView"+                               , "BlockingQueue"+                               , "Book"+                               , "Boolean"+                               , "BooleanControl"+                               , "BooleanControl.Type"+                               , "BooleanHolder"+                               , "BooleanSeqHelper"+                               , "BooleanSeqHolder"+                               , "Border"+                               , "BorderFactory"+                               , "BorderLayout"+                               , "BorderUIResource"+                               , "BorderUIResource.BevelBorderUIResource"+                               , "BorderUIResource.CompoundBorderUIResource"+                               , "BorderUIResource.EmptyBorderUIResource"+                               , "BorderUIResource.EtchedBorderUIResource"+                               , "BorderUIResource.LineBorderUIResource"+                               , "BorderUIResource.MatteBorderUIResource"+                               , "BorderUIResource.TitledBorderUIResource"+                               , "BoundedRangeModel"+                               , "Bounds"+                               , "Box"+                               , "Box.Filler"+                               , "BoxLayout"+                               , "BoxView"+                               , "BoxedValueHelper"+                               , "BreakIterator"+                               , "BrokenBarrierException"+                               , "Buffer"+                               , "BufferCapabilities"+                               , "BufferCapabilities.FlipContents"+                               , "BufferOverflowException"+                               , "BufferStrategy"+                               , "BufferUnderflowException"+                               , "BufferedImage"+                               , "BufferedImageFilter"+                               , "BufferedImageOp"+                               , "BufferedInputStream"+                               , "BufferedOutputStream"+                               , "BufferedReader"+                               , "BufferedWriter"+                               , "Button"+                               , "ButtonGroup"+                               , "ButtonModel"+                               , "ButtonUI"+                               , "Byte"+                               , "ByteArrayInputStream"+                               , "ByteArrayOutputStream"+                               , "ByteBuffer"+                               , "ByteChannel"+                               , "ByteHolder"+                               , "ByteLookupTable"+                               , "ByteOrder"+                               , "CDATASection"+                               , "CMMException"+                               , "CODESET_INCOMPATIBLE"+                               , "COMM_FAILURE"+                               , "CRC32"+                               , "CRL"+                               , "CRLException"+                               , "CRLSelector"+                               , "CSS"+                               , "CSS.Attribute"+                               , "CTX_RESTRICT_SCOPE"+                               , "CacheRequest"+                               , "CacheResponse"+                               , "CachedRowSet"+                               , "Calendar"+                               , "Callable"+                               , "CallableStatement"+                               , "Callback"+                               , "CallbackHandler"+                               , "CancelablePrintJob"+                               , "CancellationException"+                               , "CancelledKeyException"+                               , "CannotProceed"+                               , "CannotProceedException"+                               , "CannotProceedHelper"+                               , "CannotProceedHolder"+                               , "CannotRedoException"+                               , "CannotUndoException"+                               , "Canvas"+                               , "CardLayout"+                               , "Caret"+                               , "CaretEvent"+                               , "CaretListener"+                               , "CellEditor"+                               , "CellEditorListener"+                               , "CellRendererPane"+                               , "CertPath"+                               , "CertPath.CertPathRep"+                               , "CertPathBuilder"+                               , "CertPathBuilderException"+                               , "CertPathBuilderResult"+                               , "CertPathBuilderSpi"+                               , "CertPathParameters"+                               , "CertPathTrustManagerParameters"+                               , "CertPathValidator"+                               , "CertPathValidatorException"+                               , "CertPathValidatorResult"+                               , "CertPathValidatorSpi"+                               , "CertSelector"+                               , "CertStore"+                               , "CertStoreException"+                               , "CertStoreParameters"+                               , "CertStoreSpi"+                               , "Certificate"+                               , "Certificate.CertificateRep"+                               , "CertificateEncodingException"+                               , "CertificateException"+                               , "CertificateExpiredException"+                               , "CertificateFactory"+                               , "CertificateFactorySpi"+                               , "CertificateNotYetValidException"+                               , "CertificateParsingException"+                               , "ChangeEvent"+                               , "ChangeListener"+                               , "ChangedCharSetException"+                               , "Channel"+                               , "ChannelBinding"+                               , "Channels"+                               , "CharArrayReader"+                               , "CharArrayWriter"+                               , "CharBuffer"+                               , "CharConversionException"+                               , "CharHolder"+                               , "CharSeqHelper"+                               , "CharSeqHolder"+                               , "CharSequence"+                               , "Character"+                               , "Character.Subset"+                               , "Character.UnicodeBlock"+                               , "CharacterCodingException"+                               , "CharacterData"+                               , "CharacterIterator"+                               , "Charset"+                               , "CharsetDecoder"+                               , "CharsetEncoder"+                               , "CharsetProvider"+                               , "Checkbox"+                               , "CheckboxGroup"+                               , "CheckboxMenuItem"+                               , "CheckedInputStream"+                               , "CheckedOutputStream"+                               , "Checksum"+                               , "Choice"+                               , "ChoiceCallback"+                               , "ChoiceFormat"+                               , "Chromaticity"+                               , "Cipher"+                               , "CipherInputStream"+                               , "CipherOutputStream"+                               , "CipherSpi"+                               , "Class"+                               , "ClassCastException"+                               , "ClassCircularityError"+                               , "ClassDefinition"+                               , "ClassDesc"+                               , "ClassFileTransformer"+                               , "ClassFormatError"+                               , "ClassLoader"+                               , "ClassLoaderRepository"+                               , "ClassLoadingMXBean"+                               , "ClassNotFoundException"+                               , "ClientRequestInfo"+                               , "ClientRequestInfoOperations"+                               , "ClientRequestInterceptor"+                               , "ClientRequestInterceptorOperations"+                               , "Clip"+                               , "Clipboard"+                               , "ClipboardOwner"+                               , "Clob"+                               , "CloneNotSupportedException"+                               , "Cloneable"+                               , "Closeable"+                               , "ClosedByInterruptException"+                               , "ClosedChannelException"+                               , "ClosedSelectorException"+                               , "CodeSets"+                               , "CodeSigner"+                               , "CodeSource"+                               , "Codec"+                               , "CodecFactory"+                               , "CodecFactoryHelper"+                               , "CodecFactoryOperations"+                               , "CodecOperations"+                               , "CoderMalfunctionError"+                               , "CoderResult"+                               , "CodingErrorAction"+                               , "CollationElementIterator"+                               , "CollationKey"+                               , "Collator"+                               , "Collection"+                               , "CollectionCertStoreParameters"+                               , "Collections"+                               , "Color"+                               , "ColorChooserComponentFactory"+                               , "ColorChooserUI"+                               , "ColorConvertOp"+                               , "ColorModel"+                               , "ColorSelectionModel"+                               , "ColorSpace"+                               , "ColorSupported"+                               , "ColorType"+                               , "ColorUIResource"+                               , "ComboBoxEditor"+                               , "ComboBoxModel"+                               , "ComboBoxUI"+                               , "ComboPopup"+                               , "Comment"+                               , "CommunicationException"+                               , "Comparable"+                               , "Comparator"+                               , "CompilationMXBean"+                               , "Compiler"+                               , "CompletionService"+                               , "CompletionStatus"+                               , "CompletionStatusHelper"+                               , "Component"+                               , "ComponentAdapter"+                               , "ComponentColorModel"+                               , "ComponentEvent"+                               , "ComponentIdHelper"+                               , "ComponentInputMap"+                               , "ComponentInputMapUIResource"+                               , "ComponentListener"+                               , "ComponentOrientation"+                               , "ComponentSampleModel"+                               , "ComponentUI"+                               , "ComponentView"+                               , "Composite"+                               , "CompositeContext"+                               , "CompositeData"+                               , "CompositeDataSupport"+                               , "CompositeName"+                               , "CompositeType"+                               , "CompositeView"+                               , "CompoundBorder"+                               , "CompoundControl"+                               , "CompoundControl.Type"+                               , "CompoundEdit"+                               , "CompoundName"+                               , "Compression"+                               , "ConcurrentHashMap"+                               , "ConcurrentLinkedQueue"+                               , "ConcurrentMap"+                               , "ConcurrentModificationException"+                               , "Condition"+                               , "Configuration"+                               , "ConfigurationException"+                               , "ConfirmationCallback"+                               , "ConnectException"+                               , "ConnectIOException"+                               , "Connection"+                               , "ConnectionEvent"+                               , "ConnectionEventListener"+                               , "ConnectionPendingException"+                               , "ConnectionPoolDataSource"+                               , "ConsoleHandler"+                               , "Constructor"+                               , "Container"+                               , "ContainerAdapter"+                               , "ContainerEvent"+                               , "ContainerListener"+                               , "ContainerOrderFocusTraversalPolicy"+                               , "ContentHandler"+                               , "ContentHandlerFactory"+                               , "ContentModel"+                               , "Context"+                               , "ContextList"+                               , "ContextNotEmptyException"+                               , "ContextualRenderedImageFactory"+                               , "Control"+                               , "Control.Type"+                               , "ControlFactory"+                               , "ControllerEventListener"+                               , "ConvolveOp"+                               , "CookieHandler"+                               , "CookieHolder"+                               , "Copies"+                               , "CopiesSupported"+                               , "CopyOnWriteArrayList"+                               , "CopyOnWriteArraySet"+                               , "CountDownLatch"+                               , "CounterMonitor"+                               , "CounterMonitorMBean"+                               , "CredentialException"+                               , "CredentialExpiredException"+                               , "CredentialNotFoundException"+                               , "CropImageFilter"+                               , "CubicCurve2D"+                               , "CubicCurve2D.Double"+                               , "CubicCurve2D.Float"+                               , "Currency"+                               , "Current"+                               , "CurrentHelper"+                               , "CurrentHolder"+                               , "CurrentOperations"+                               , "Cursor"+                               , "CustomMarshal"+                               , "CustomValue"+                               , "Customizer"+                               , "CyclicBarrier"+                               , "DATA_CONVERSION"+                               , "DESKeySpec"+                               , "DESedeKeySpec"+                               , "DGC"+                               , "DHGenParameterSpec"+                               , "DHKey"+                               , "DHParameterSpec"+                               , "DHPrivateKey"+                               , "DHPrivateKeySpec"+                               , "DHPublicKey"+                               , "DHPublicKeySpec"+                               , "DISCARDING"+                               , "DOMConfiguration"+                               , "DOMError"+                               , "DOMErrorHandler"+                               , "DOMException"+                               , "DOMImplementation"+                               , "DOMImplementationLS"+                               , "DOMImplementationList"+                               , "DOMImplementationRegistry"+                               , "DOMImplementationSource"+                               , "DOMLocator"+                               , "DOMResult"+                               , "DOMSource"+                               , "DOMStringList"+                               , "DSAKey"+                               , "DSAKeyPairGenerator"+                               , "DSAParameterSpec"+                               , "DSAParams"+                               , "DSAPrivateKey"+                               , "DSAPrivateKeySpec"+                               , "DSAPublicKey"+                               , "DSAPublicKeySpec"+                               , "DTD"+                               , "DTDConstants"+                               , "DTDHandler"+                               , "DataBuffer"+                               , "DataBufferByte"+                               , "DataBufferDouble"+                               , "DataBufferFloat"+                               , "DataBufferInt"+                               , "DataBufferShort"+                               , "DataBufferUShort"+                               , "DataFlavor"+                               , "DataFormatException"+                               , "DataInput"+                               , "DataInputStream"+                               , "DataLine"+                               , "DataLine.Info"+                               , "DataOutput"+                               , "DataOutputStream"+                               , "DataSource"+                               , "DataTruncation"+                               , "DatabaseMetaData"+                               , "DatagramChannel"+                               , "DatagramPacket"+                               , "DatagramSocket"+                               , "DatagramSocketImpl"+                               , "DatagramSocketImplFactory"+                               , "DatatypeConfigurationException"+                               , "DatatypeConstants"+                               , "DatatypeConstants.Field"+                               , "DatatypeFactory"+                               , "Date"+                               , "DateFormat"+                               , "DateFormat.Field"+                               , "DateFormatSymbols"+                               , "DateFormatter"+                               , "DateTimeAtCompleted"+                               , "DateTimeAtCreation"+                               , "DateTimeAtProcessing"+                               , "DateTimeSyntax"+                               , "DebugGraphics"+                               , "DecimalFormat"+                               , "DecimalFormatSymbols"+                               , "DeclHandler"+                               , "DefaultBoundedRangeModel"+                               , "DefaultButtonModel"+                               , "DefaultCaret"+                               , "DefaultCellEditor"+                               , "DefaultColorSelectionModel"+                               , "DefaultComboBoxModel"+                               , "DefaultDesktopManager"+                               , "DefaultEditorKit"+                               , "DefaultEditorKit.BeepAction"+                               , "DefaultEditorKit.CopyAction"+                               , "DefaultEditorKit.CutAction"+                               , "DefaultEditorKit.DefaultKeyTypedAction"+                               , "DefaultEditorKit.InsertBreakAction"+                               , "DefaultEditorKit.InsertContentAction"+                               , "DefaultEditorKit.InsertTabAction"+                               , "DefaultEditorKit.PasteAction"+                               , "DefaultFocusManager"+                               , "DefaultFocusTraversalPolicy"+                               , "DefaultFormatter"+                               , "DefaultFormatterFactory"+                               , "DefaultHandler"+                               , "DefaultHandler2"+                               , "DefaultHighlighter"+                               , "DefaultHighlighter.DefaultHighlightPainter"+                               , "DefaultKeyboardFocusManager"+                               , "DefaultListCellRenderer"+                               , "DefaultListCellRenderer.UIResource"+                               , "DefaultListModel"+                               , "DefaultListSelectionModel"+                               , "DefaultLoaderRepository"+                               , "DefaultMenuLayout"+                               , "DefaultMetalTheme"+                               , "DefaultMutableTreeNode"+                               , "DefaultPersistenceDelegate"+                               , "DefaultSingleSelectionModel"+                               , "DefaultStyledDocument"+                               , "DefaultStyledDocument.AttributeUndoableEdit"+                               , "DefaultStyledDocument.ElementSpec"+                               , "DefaultTableCellRenderer"+                               , "DefaultTableCellRenderer.UIResource"+                               , "DefaultTableColumnModel"+                               , "DefaultTableModel"+                               , "DefaultTextUI"+                               , "DefaultTreeCellEditor"+                               , "DefaultTreeCellRenderer"+                               , "DefaultTreeModel"+                               , "DefaultTreeSelectionModel"+                               , "DefinitionKind"+                               , "DefinitionKindHelper"+                               , "Deflater"+                               , "DeflaterOutputStream"+                               , "DelayQueue"+                               , "Delayed"+                               , "Delegate"+                               , "DelegationPermission"+                               , "Deprecated"+                               , "Descriptor"+                               , "DescriptorAccess"+                               , "DescriptorSupport"+                               , "DesignMode"+                               , "DesktopIconUI"+                               , "DesktopManager"+                               , "DesktopPaneUI"+                               , "Destination"+                               , "DestroyFailedException"+                               , "Destroyable"+                               , "Dialog"+                               , "Dictionary"+                               , "DigestException"+                               , "DigestInputStream"+                               , "DigestOutputStream"+                               , "Dimension"+                               , "Dimension2D"+                               , "DimensionUIResource"+                               , "DirContext"+                               , "DirObjectFactory"+                               , "DirStateFactory"+                               , "DirStateFactory.Result"+                               , "DirectColorModel"+                               , "DirectoryManager"+                               , "DisplayMode"+                               , "DnDConstants"+                               , "Doc"+                               , "DocAttribute"+                               , "DocAttributeSet"+                               , "DocFlavor"+                               , "DocFlavor.BYTE_ARRAY"+                               , "DocFlavor.CHAR_ARRAY"+                               , "DocFlavor.INPUT_STREAM"+                               , "DocFlavor.READER"+                               , "DocFlavor.SERVICE_FORMATTED"+                               , "DocFlavor.STRING"+                               , "DocFlavor.URL"+                               , "DocPrintJob"+                               , "Document"+                               , "DocumentBuilder"+                               , "DocumentBuilderFactory"+                               , "DocumentEvent"+                               , "DocumentEvent.ElementChange"+                               , "DocumentEvent.EventType"+                               , "DocumentFilter"+                               , "DocumentFilter.FilterBypass"+                               , "DocumentFragment"+                               , "DocumentHandler"+                               , "DocumentListener"+                               , "DocumentName"+                               , "DocumentParser"+                               , "DocumentType"+                               , "Documented"+                               , "DomainCombiner"+                               , "DomainManager"+                               , "DomainManagerOperations"+                               , "Double"+                               , "DoubleBuffer"+                               , "DoubleHolder"+                               , "DoubleSeqHelper"+                               , "DoubleSeqHolder"+                               , "DragGestureEvent"+                               , "DragGestureListener"+                               , "DragGestureRecognizer"+                               , "DragSource"+                               , "DragSourceAdapter"+                               , "DragSourceContext"+                               , "DragSourceDragEvent"+                               , "DragSourceDropEvent"+                               , "DragSourceEvent"+                               , "DragSourceListener"+                               , "DragSourceMotionListener"+                               , "Driver"+                               , "DriverManager"+                               , "DriverPropertyInfo"+                               , "DropTarget"+                               , "DropTarget.DropTargetAutoScroller"+                               , "DropTargetAdapter"+                               , "DropTargetContext"+                               , "DropTargetDragEvent"+                               , "DropTargetDropEvent"+                               , "DropTargetEvent"+                               , "DropTargetListener"+                               , "DuplicateFormatFlagsException"+                               , "DuplicateName"+                               , "DuplicateNameHelper"+                               , "Duration"+                               , "DynAny"+                               , "DynAnyFactory"+                               , "DynAnyFactoryHelper"+                               , "DynAnyFactoryOperations"+                               , "DynAnyHelper"+                               , "DynAnyOperations"+                               , "DynAnySeqHelper"+                               , "DynArray"+                               , "DynArrayHelper"+                               , "DynArrayOperations"+                               , "DynEnum"+                               , "DynEnumHelper"+                               , "DynEnumOperations"+                               , "DynFixed"+                               , "DynFixedHelper"+                               , "DynFixedOperations"+                               , "DynSequence"+                               , "DynSequenceHelper"+                               , "DynSequenceOperations"+                               , "DynStruct"+                               , "DynStructHelper"+                               , "DynStructOperations"+                               , "DynUnion"+                               , "DynUnionHelper"+                               , "DynUnionOperations"+                               , "DynValue"+                               , "DynValueBox"+                               , "DynValueBoxOperations"+                               , "DynValueCommon"+                               , "DynValueCommonOperations"+                               , "DynValueHelper"+                               , "DynValueOperations"+                               , "DynamicImplementation"+                               , "DynamicMBean"+                               , "ECField"+                               , "ECFieldF2m"+                               , "ECFieldFp"+                               , "ECGenParameterSpec"+                               , "ECKey"+                               , "ECParameterSpec"+                               , "ECPoint"+                               , "ECPrivateKey"+                               , "ECPrivateKeySpec"+                               , "ECPublicKey"+                               , "ECPublicKeySpec"+                               , "ENCODING_CDR_ENCAPS"+                               , "EOFException"+                               , "EditorKit"+                               , "Element"+                               , "ElementIterator"+                               , "ElementType"+                               , "Ellipse2D"+                               , "Ellipse2D.Double"+                               , "Ellipse2D.Float"+                               , "EllipticCurve"+                               , "EmptyBorder"+                               , "EmptyStackException"+                               , "EncodedKeySpec"+                               , "Encoder"+                               , "Encoding"+                               , "EncryptedPrivateKeyInfo"+                               , "Entity"+                               , "EntityReference"+                               , "EntityResolver"+                               , "EntityResolver2"+                               , "Enum"+                               , "EnumConstantNotPresentException"+                               , "EnumControl"+                               , "EnumControl.Type"+                               , "EnumMap"+                               , "EnumSet"+                               , "EnumSyntax"+                               , "Enumeration"+                               , "Environment"+                               , "Error"+                               , "ErrorHandler"+                               , "ErrorListener"+                               , "ErrorManager"+                               , "EtchedBorder"+                               , "Event"+                               , "EventContext"+                               , "EventDirContext"+                               , "EventHandler"+                               , "EventListener"+                               , "EventListenerList"+                               , "EventListenerProxy"+                               , "EventObject"+                               , "EventQueue"+                               , "EventSetDescriptor"+                               , "Exception"+                               , "ExceptionDetailMessage"+                               , "ExceptionInInitializerError"+                               , "ExceptionList"+                               , "ExceptionListener"+                               , "Exchanger"+                               , "ExecutionException"+                               , "Executor"+                               , "ExecutorCompletionService"+                               , "ExecutorService"+                               , "Executors"+                               , "ExemptionMechanism"+                               , "ExemptionMechanismException"+                               , "ExemptionMechanismSpi"+                               , "ExpandVetoException"+                               , "ExportException"+                               , "Expression"+                               , "ExtendedRequest"+                               , "ExtendedResponse"+                               , "Externalizable"+                               , "FREE_MEM"+                               , "FactoryConfigurationError"+                               , "FailedLoginException"+                               , "FeatureDescriptor"+                               , "Fidelity"+                               , "Field"+                               , "FieldNameHelper"+                               , "FieldPosition"+                               , "FieldView"+                               , "File"+                               , "FileCacheImageInputStream"+                               , "FileCacheImageOutputStream"+                               , "FileChannel"+                               , "FileChannel.MapMode"+                               , "FileChooserUI"+                               , "FileDescriptor"+                               , "FileDialog"+                               , "FileFilter"+                               , "FileHandler"+                               , "FileImageInputStream"+                               , "FileImageOutputStream"+                               , "FileInputStream"+                               , "FileLock"+                               , "FileLockInterruptionException"+                               , "FileNameMap"+                               , "FileNotFoundException"+                               , "FileOutputStream"+                               , "FilePermission"+                               , "FileReader"+                               , "FileSystemView"+                               , "FileView"+                               , "FileWriter"+                               , "FilenameFilter"+                               , "Filter"+                               , "FilterInputStream"+                               , "FilterOutputStream"+                               , "FilterReader"+                               , "FilterWriter"+                               , "FilteredImageSource"+                               , "FilteredRowSet"+                               , "Finishings"+                               , "FixedHeightLayoutCache"+                               , "FixedHolder"+                               , "FlatteningPathIterator"+                               , "FlavorEvent"+                               , "FlavorException"+                               , "FlavorListener"+                               , "FlavorMap"+                               , "FlavorTable"+                               , "Float"+                               , "FloatBuffer"+                               , "FloatControl"+                               , "FloatControl.Type"+                               , "FloatHolder"+                               , "FloatSeqHelper"+                               , "FloatSeqHolder"+                               , "FlowLayout"+                               , "FlowView"+                               , "FlowView.FlowStrategy"+                               , "Flushable"+                               , "FocusAdapter"+                               , "FocusEvent"+                               , "FocusListener"+                               , "FocusManager"+                               , "FocusTraversalPolicy"+                               , "Font"+                               , "FontFormatException"+                               , "FontMetrics"+                               , "FontRenderContext"+                               , "FontUIResource"+                               , "FormSubmitEvent"+                               , "FormSubmitEvent.MethodType"+                               , "FormView"+                               , "Format"+                               , "Format.Field"+                               , "FormatConversionProvider"+                               , "FormatFlagsConversionMismatchException"+                               , "FormatMismatch"+                               , "FormatMismatchHelper"+                               , "Formattable"+                               , "FormattableFlags"+                               , "Formatter"+                               , "FormatterClosedException"+                               , "ForwardRequest"+                               , "ForwardRequestHelper"+                               , "Frame"+                               , "Future"+                               , "FutureTask"+                               , "GSSContext"+                               , "GSSCredential"+                               , "GSSException"+                               , "GSSManager"+                               , "GSSName"+                               , "GZIPInputStream"+                               , "GZIPOutputStream"+                               , "GapContent"+                               , "GarbageCollectorMXBean"+                               , "GatheringByteChannel"+                               , "GaugeMonitor"+                               , "GaugeMonitorMBean"+                               , "GeneralPath"+                               , "GeneralSecurityException"+                               , "GenericArrayType"+                               , "GenericDeclaration"+                               , "GenericSignatureFormatError"+                               , "GlyphJustificationInfo"+                               , "GlyphMetrics"+                               , "GlyphVector"+                               , "GlyphView"+                               , "GlyphView.GlyphPainter"+                               , "GradientPaint"+                               , "GraphicAttribute"+                               , "Graphics"+                               , "Graphics2D"+                               , "GraphicsConfigTemplate"+                               , "GraphicsConfiguration"+                               , "GraphicsDevice"+                               , "GraphicsEnvironment"+                               , "GrayFilter"+                               , "GregorianCalendar"+                               , "GridBagConstraints"+                               , "GridBagLayout"+                               , "GridLayout"+                               , "Group"+                               , "Guard"+                               , "GuardedObject"+                               , "HOLDING"+                               , "HTML"+                               , "HTML.Attribute"+                               , "HTML.Tag"+                               , "HTML.UnknownTag"+                               , "HTMLDocument"+                               , "HTMLDocument.Iterator"+                               , "HTMLEditorKit"+                               , "HTMLEditorKit.HTMLFactory"+                               , "HTMLEditorKit.HTMLTextAction"+                               , "HTMLEditorKit.InsertHTMLTextAction"+                               , "HTMLEditorKit.LinkController"+                               , "HTMLEditorKit.Parser"+                               , "HTMLEditorKit.ParserCallback"+                               , "HTMLFrameHyperlinkEvent"+                               , "HTMLWriter"+                               , "Handler"+                               , "HandlerBase"+                               , "HandshakeCompletedEvent"+                               , "HandshakeCompletedListener"+                               , "HasControls"+                               , "HashAttributeSet"+                               , "HashDocAttributeSet"+                               , "HashMap"+                               , "HashPrintJobAttributeSet"+                               , "HashPrintRequestAttributeSet"+                               , "HashPrintServiceAttributeSet"+                               , "HashSet"+                               , "Hashtable"+                               , "HeadlessException"+                               , "HierarchyBoundsAdapter"+                               , "HierarchyBoundsListener"+                               , "HierarchyEvent"+                               , "HierarchyListener"+                               , "Highlighter"+                               , "Highlighter.Highlight"+                               , "Highlighter.HighlightPainter"+                               , "HostnameVerifier"+                               , "HttpRetryException"+                               , "HttpURLConnection"+                               , "HttpsURLConnection"+                               , "HyperlinkEvent"+                               , "HyperlinkEvent.EventType"+                               , "HyperlinkListener"+                               , "ICC_ColorSpace"+                               , "ICC_Profile"+                               , "ICC_ProfileGray"+                               , "ICC_ProfileRGB"+                               , "IDLEntity"+                               , "IDLType"+                               , "IDLTypeHelper"+                               , "IDLTypeOperations"+                               , "ID_ASSIGNMENT_POLICY_ID"+                               , "ID_UNIQUENESS_POLICY_ID"+                               , "IIOByteBuffer"+                               , "IIOException"+                               , "IIOImage"+                               , "IIOInvalidTreeException"+                               , "IIOMetadata"+                               , "IIOMetadataController"+                               , "IIOMetadataFormat"+                               , "IIOMetadataFormatImpl"+                               , "IIOMetadataNode"+                               , "IIOParam"+                               , "IIOParamController"+                               , "IIOReadProgressListener"+                               , "IIOReadUpdateListener"+                               , "IIOReadWarningListener"+                               , "IIORegistry"+                               , "IIOServiceProvider"+                               , "IIOWriteProgressListener"+                               , "IIOWriteWarningListener"+                               , "IMPLICIT_ACTIVATION_POLICY_ID"+                               , "IMP_LIMIT"+                               , "INACTIVE"+                               , "INITIALIZE"+                               , "INTERNAL"+                               , "INTF_REPOS"+                               , "INVALID_ACTIVITY"+                               , "INVALID_TRANSACTION"+                               , "INV_FLAG"+                               , "INV_IDENT"+                               , "INV_OBJREF"+                               , "INV_POLICY"+                               , "IOException"+                               , "IOR"+                               , "IORHelper"+                               , "IORHolder"+                               , "IORInfo"+                               , "IORInfoOperations"+                               , "IORInterceptor"+                               , "IORInterceptorOperations"+                               , "IORInterceptor_3_0"+                               , "IORInterceptor_3_0Helper"+                               , "IORInterceptor_3_0Holder"+                               , "IORInterceptor_3_0Operations"+                               , "IRObject"+                               , "IRObjectOperations"+                               , "Icon"+                               , "IconUIResource"+                               , "IconView"+                               , "IdAssignmentPolicy"+                               , "IdAssignmentPolicyOperations"+                               , "IdAssignmentPolicyValue"+                               , "IdUniquenessPolicy"+                               , "IdUniquenessPolicyOperations"+                               , "IdUniquenessPolicyValue"+                               , "IdentifierHelper"+                               , "Identity"+                               , "IdentityHashMap"+                               , "IdentityScope"+                               , "IllegalAccessError"+                               , "IllegalAccessException"+                               , "IllegalArgumentException"+                               , "IllegalBlockSizeException"+                               , "IllegalBlockingModeException"+                               , "IllegalCharsetNameException"+                               , "IllegalClassFormatException"+                               , "IllegalComponentStateException"+                               , "IllegalFormatCodePointException"+                               , "IllegalFormatConversionException"+                               , "IllegalFormatException"+                               , "IllegalFormatFlagsException"+                               , "IllegalFormatPrecisionException"+                               , "IllegalFormatWidthException"+                               , "IllegalMonitorStateException"+                               , "IllegalPathStateException"+                               , "IllegalSelectorException"+                               , "IllegalStateException"+                               , "IllegalThreadStateException"+                               , "Image"+                               , "ImageCapabilities"+                               , "ImageConsumer"+                               , "ImageFilter"+                               , "ImageGraphicAttribute"+                               , "ImageIO"+                               , "ImageIcon"+                               , "ImageInputStream"+                               , "ImageInputStreamImpl"+                               , "ImageInputStreamSpi"+                               , "ImageObserver"+                               , "ImageOutputStream"+                               , "ImageOutputStreamImpl"+                               , "ImageOutputStreamSpi"+                               , "ImageProducer"+                               , "ImageReadParam"+                               , "ImageReader"+                               , "ImageReaderSpi"+                               , "ImageReaderWriterSpi"+                               , "ImageTranscoder"+                               , "ImageTranscoderSpi"+                               , "ImageTypeSpecifier"+                               , "ImageView"+                               , "ImageWriteParam"+                               , "ImageWriter"+                               , "ImageWriterSpi"+                               , "ImagingOpException"+                               , "ImplicitActivationPolicy"+                               , "ImplicitActivationPolicyOperations"+                               , "ImplicitActivationPolicyValue"+                               , "IncompatibleClassChangeError"+                               , "IncompleteAnnotationException"+                               , "InconsistentTypeCode"+                               , "InconsistentTypeCodeHelper"+                               , "IndexColorModel"+                               , "IndexOutOfBoundsException"+                               , "IndexedPropertyChangeEvent"+                               , "IndexedPropertyDescriptor"+                               , "IndirectionException"+                               , "Inet4Address"+                               , "Inet6Address"+                               , "InetAddress"+                               , "InetSocketAddress"+                               , "Inflater"+                               , "InflaterInputStream"+                               , "InheritableThreadLocal"+                               , "Inherited"+                               , "InitialContext"+                               , "InitialContextFactory"+                               , "InitialContextFactoryBuilder"+                               , "InitialDirContext"+                               , "InitialLdapContext"+                               , "InlineView"+                               , "InputContext"+                               , "InputEvent"+                               , "InputMap"+                               , "InputMapUIResource"+                               , "InputMethod"+                               , "InputMethodContext"+                               , "InputMethodDescriptor"+                               , "InputMethodEvent"+                               , "InputMethodHighlight"+                               , "InputMethodListener"+                               , "InputMethodRequests"+                               , "InputMismatchException"+                               , "InputSource"+                               , "InputStream"+                               , "InputStreamReader"+                               , "InputSubset"+                               , "InputVerifier"+                               , "Insets"+                               , "InsetsUIResource"+                               , "InstanceAlreadyExistsException"+                               , "InstanceNotFoundException"+                               , "InstantiationError"+                               , "InstantiationException"+                               , "Instrument"+                               , "Instrumentation"+                               , "InsufficientResourcesException"+                               , "IntBuffer"+                               , "IntHolder"+                               , "Integer"+                               , "IntegerSyntax"+                               , "Interceptor"+                               , "InterceptorOperations"+                               , "InternalError"+                               , "InternalFrameAdapter"+                               , "InternalFrameEvent"+                               , "InternalFrameFocusTraversalPolicy"+                               , "InternalFrameListener"+                               , "InternalFrameUI"+                               , "InternationalFormatter"+                               , "InterruptedException"+                               , "InterruptedIOException"+                               , "InterruptedNamingException"+                               , "InterruptibleChannel"+                               , "IntrospectionException"+                               , "Introspector"+                               , "Invalid"+                               , "InvalidActivityException"+                               , "InvalidAddress"+                               , "InvalidAddressHelper"+                               , "InvalidAddressHolder"+                               , "InvalidAlgorithmParameterException"+                               , "InvalidApplicationException"+                               , "InvalidAttributeIdentifierException"+                               , "InvalidAttributeValueException"+                               , "InvalidAttributesException"+                               , "InvalidClassException"+                               , "InvalidDnDOperationException"+                               , "InvalidKeyException"+                               , "InvalidKeySpecException"+                               , "InvalidMarkException"+                               , "InvalidMidiDataException"+                               , "InvalidName"+                               , "InvalidNameException"+                               , "InvalidNameHelper"+                               , "InvalidNameHolder"+                               , "InvalidObjectException"+                               , "InvalidOpenTypeException"+                               , "InvalidParameterException"+                               , "InvalidParameterSpecException"+                               , "InvalidPolicy"+                               , "InvalidPolicyHelper"+                               , "InvalidPreferencesFormatException"+                               , "InvalidPropertiesFormatException"+                               , "InvalidRelationIdException"+                               , "InvalidRelationServiceException"+                               , "InvalidRelationTypeException"+                               , "InvalidRoleInfoException"+                               , "InvalidRoleValueException"+                               , "InvalidSearchControlsException"+                               , "InvalidSearchFilterException"+                               , "InvalidSeq"+                               , "InvalidSlot"+                               , "InvalidSlotHelper"+                               , "InvalidTargetObjectTypeException"+                               , "InvalidTransactionException"+                               , "InvalidTypeForEncoding"+                               , "InvalidTypeForEncodingHelper"+                               , "InvalidValue"+                               , "InvalidValueHelper"+                               , "InvocationEvent"+                               , "InvocationHandler"+                               , "InvocationTargetException"+                               , "InvokeHandler"+                               , "IstringHelper"+                               , "ItemEvent"+                               , "ItemListener"+                               , "ItemSelectable"+                               , "Iterable"+                               , "Iterator"+                               , "IvParameterSpec"+                               , "JApplet"+                               , "JButton"+                               , "JCheckBox"+                               , "JCheckBoxMenuItem"+                               , "JColorChooser"+                               , "JComboBox"+                               , "JComboBox.KeySelectionManager"+                               , "JComponent"+                               , "JDesktopPane"+                               , "JDialog"+                               , "JEditorPane"+                               , "JFileChooser"+                               , "JFormattedTextField"+                               , "JFormattedTextField.AbstractFormatter"+                               , "JFormattedTextField.AbstractFormatterFactory"+                               , "JFrame"+                               , "JInternalFrame"+                               , "JInternalFrame.JDesktopIcon"+                               , "JLabel"+                               , "JLayeredPane"+                               , "JList"+                               , "JMException"+                               , "JMRuntimeException"+                               , "JMXAuthenticator"+                               , "JMXConnectionNotification"+                               , "JMXConnector"+                               , "JMXConnectorFactory"+                               , "JMXConnectorProvider"+                               , "JMXConnectorServer"+                               , "JMXConnectorServerFactory"+                               , "JMXConnectorServerMBean"+                               , "JMXConnectorServerProvider"+                               , "JMXPrincipal"+                               , "JMXProviderException"+                               , "JMXServerErrorException"+                               , "JMXServiceURL"+                               , "JMenu"+                               , "JMenuBar"+                               , "JMenuItem"+                               , "JOptionPane"+                               , "JPEGHuffmanTable"+                               , "JPEGImageReadParam"+                               , "JPEGImageWriteParam"+                               , "JPEGQTable"+                               , "JPanel"+                               , "JPasswordField"+                               , "JPopupMenu"+                               , "JPopupMenu.Separator"+                               , "JProgressBar"+                               , "JRadioButton"+                               , "JRadioButtonMenuItem"+                               , "JRootPane"+                               , "JScrollBar"+                               , "JScrollPane"+                               , "JSeparator"+                               , "JSlider"+                               , "JSpinner"+                               , "JSpinner.DateEditor"+                               , "JSpinner.DefaultEditor"+                               , "JSpinner.ListEditor"+                               , "JSpinner.NumberEditor"+                               , "JSplitPane"+                               , "JTabbedPane"+                               , "JTable"+                               , "JTable.PrintMode"+                               , "JTableHeader"+                               , "JTextArea"+                               , "JTextComponent"+                               , "JTextComponent.KeyBinding"+                               , "JTextField"+                               , "JTextPane"+                               , "JToggleButton"+                               , "JToggleButton.ToggleButtonModel"+                               , "JToolBar"+                               , "JToolBar.Separator"+                               , "JToolTip"+                               , "JTree"+                               , "JTree.DynamicUtilTreeNode"+                               , "JTree.EmptySelectionModel"+                               , "JViewport"+                               , "JWindow"+                               , "JarEntry"+                               , "JarException"+                               , "JarFile"+                               , "JarInputStream"+                               , "JarOutputStream"+                               , "JarURLConnection"+                               , "JdbcRowSet"+                               , "JobAttributes"+                               , "JobAttributes.DefaultSelectionType"+                               , "JobAttributes.DestinationType"+                               , "JobAttributes.DialogType"+                               , "JobAttributes.MultipleDocumentHandlingType"+                               , "JobAttributes.SidesType"+                               , "JobHoldUntil"+                               , "JobImpressions"+                               , "JobImpressionsCompleted"+                               , "JobImpressionsSupported"+                               , "JobKOctets"+                               , "JobKOctetsProcessed"+                               , "JobKOctetsSupported"+                               , "JobMediaSheets"+                               , "JobMediaSheetsCompleted"+                               , "JobMediaSheetsSupported"+                               , "JobMessageFromOperator"+                               , "JobName"+                               , "JobOriginatingUserName"+                               , "JobPriority"+                               , "JobPrioritySupported"+                               , "JobSheets"+                               , "JobState"+                               , "JobStateReason"+                               , "JobStateReasons"+                               , "JoinRowSet"+                               , "Joinable"+                               , "KerberosKey"+                               , "KerberosPrincipal"+                               , "KerberosTicket"+                               , "Kernel"+                               , "Key"+                               , "KeyAdapter"+                               , "KeyAgreement"+                               , "KeyAgreementSpi"+                               , "KeyAlreadyExistsException"+                               , "KeyEvent"+                               , "KeyEventDispatcher"+                               , "KeyEventPostProcessor"+                               , "KeyException"+                               , "KeyFactory"+                               , "KeyFactorySpi"+                               , "KeyGenerator"+                               , "KeyGeneratorSpi"+                               , "KeyListener"+                               , "KeyManagementException"+                               , "KeyManager"+                               , "KeyManagerFactory"+                               , "KeyManagerFactorySpi"+                               , "KeyPair"+                               , "KeyPairGenerator"+                               , "KeyPairGeneratorSpi"+                               , "KeyRep"+                               , "KeyRep.Type"+                               , "KeySpec"+                               , "KeyStore"+                               , "KeyStore.Builder"+                               , "KeyStore.CallbackHandlerProtection"+                               , "KeyStore.Entry"+                               , "KeyStore.LoadStoreParameter"+                               , "KeyStore.PasswordProtection"+                               , "KeyStore.PrivateKeyEntry"+                               , "KeyStore.ProtectionParameter"+                               , "KeyStore.SecretKeyEntry"+                               , "KeyStore.TrustedCertificateEntry"+                               , "KeyStoreBuilderParameters"+                               , "KeyStoreException"+                               , "KeyStoreSpi"+                               , "KeyStroke"+                               , "KeyboardFocusManager"+                               , "Keymap"+                               , "LDAPCertStoreParameters"+                               , "LIFESPAN_POLICY_ID"+                               , "LOCATION_FORWARD"+                               , "LSException"+                               , "LSInput"+                               , "LSLoadEvent"+                               , "LSOutput"+                               , "LSParser"+                               , "LSParserFilter"+                               , "LSProgressEvent"+                               , "LSResourceResolver"+                               , "LSSerializer"+                               , "LSSerializerFilter"+                               , "Label"+                               , "LabelUI"+                               , "LabelView"+                               , "LanguageCallback"+                               , "LastOwnerException"+                               , "LayeredHighlighter"+                               , "LayeredHighlighter.LayerPainter"+                               , "LayoutFocusTraversalPolicy"+                               , "LayoutManager"+                               , "LayoutManager2"+                               , "LayoutQueue"+                               , "LdapContext"+                               , "LdapName"+                               , "LdapReferralException"+                               , "Lease"+                               , "Level"+                               , "LexicalHandler"+                               , "LifespanPolicy"+                               , "LifespanPolicyOperations"+                               , "LifespanPolicyValue"+                               , "LimitExceededException"+                               , "Line"+                               , "Line.Info"+                               , "Line2D"+                               , "Line2D.Double"+                               , "Line2D.Float"+                               , "LineBorder"+                               , "LineBreakMeasurer"+                               , "LineEvent"+                               , "LineEvent.Type"+                               , "LineListener"+                               , "LineMetrics"+                               , "LineNumberInputStream"+                               , "LineNumberReader"+                               , "LineUnavailableException"+                               , "LinkException"+                               , "LinkLoopException"+                               , "LinkRef"+                               , "LinkageError"+                               , "LinkedBlockingQueue"+                               , "LinkedHashMap"+                               , "LinkedHashSet"+                               , "LinkedList"+                               , "List"+                               , "ListCellRenderer"+                               , "ListDataEvent"+                               , "ListDataListener"+                               , "ListIterator"+                               , "ListModel"+                               , "ListResourceBundle"+                               , "ListSelectionEvent"+                               , "ListSelectionListener"+                               , "ListSelectionModel"+                               , "ListUI"+                               , "ListView"+                               , "ListenerNotFoundException"+                               , "LoaderHandler"+                               , "LocalObject"+                               , "Locale"+                               , "LocateRegistry"+                               , "Locator"+                               , "Locator2"+                               , "Locator2Impl"+                               , "LocatorImpl"+                               , "Lock"+                               , "LockSupport"+                               , "LogManager"+                               , "LogRecord"+                               , "LogStream"+                               , "Logger"+                               , "LoggingMXBean"+                               , "LoggingPermission"+                               , "LoginContext"+                               , "LoginException"+                               , "LoginModule"+                               , "Long"+                               , "LongBuffer"+                               , "LongHolder"+                               , "LongLongSeqHelper"+                               , "LongLongSeqHolder"+                               , "LongSeqHelper"+                               , "LongSeqHolder"+                               , "LookAndFeel"+                               , "LookupOp"+                               , "LookupTable"+                               , "MARSHAL"+                               , "MBeanAttributeInfo"+                               , "MBeanConstructorInfo"+                               , "MBeanException"+                               , "MBeanFeatureInfo"+                               , "MBeanInfo"+                               , "MBeanNotificationInfo"+                               , "MBeanOperationInfo"+                               , "MBeanParameterInfo"+                               , "MBeanPermission"+                               , "MBeanRegistration"+                               , "MBeanRegistrationException"+                               , "MBeanServer"+                               , "MBeanServerBuilder"+                               , "MBeanServerConnection"+                               , "MBeanServerDelegate"+                               , "MBeanServerDelegateMBean"+                               , "MBeanServerFactory"+                               , "MBeanServerForwarder"+                               , "MBeanServerInvocationHandler"+                               , "MBeanServerNotification"+                               , "MBeanServerNotificationFilter"+                               , "MBeanServerPermission"+                               , "MBeanTrustPermission"+                               , "MGF1ParameterSpec"+                               , "MLet"+                               , "MLetMBean"+                               , "Mac"+                               , "MacSpi"+                               , "MalformedInputException"+                               , "MalformedLinkException"+                               , "MalformedObjectNameException"+                               , "MalformedParameterizedTypeException"+                               , "MalformedURLException"+                               , "ManageReferralControl"+                               , "ManagementFactory"+                               , "ManagementPermission"+                               , "ManagerFactoryParameters"+                               , "Manifest"+                               , "Map"+                               , "Map.Entry"+                               , "MappedByteBuffer"+                               , "MarshalException"+                               , "MarshalledObject"+                               , "MaskFormatter"+                               , "MatchResult"+                               , "Matcher"+                               , "Math"+                               , "MathContext"+                               , "MatteBorder"+                               , "Media"+                               , "MediaName"+                               , "MediaPrintableArea"+                               , "MediaSize"+                               , "MediaSize.Engineering"+                               , "MediaSize.ISO"+                               , "MediaSize.JIS"+                               , "MediaSize.NA"+                               , "MediaSize.Other"+                               , "MediaSizeName"+                               , "MediaTracker"+                               , "MediaTray"+                               , "Member"+                               , "MemoryCacheImageInputStream"+                               , "MemoryCacheImageOutputStream"+                               , "MemoryHandler"+                               , "MemoryImageSource"+                               , "MemoryMXBean"+                               , "MemoryManagerMXBean"+                               , "MemoryNotificationInfo"+                               , "MemoryPoolMXBean"+                               , "MemoryType"+                               , "MemoryUsage"+                               , "Menu"+                               , "MenuBar"+                               , "MenuBarUI"+                               , "MenuComponent"+                               , "MenuContainer"+                               , "MenuDragMouseEvent"+                               , "MenuDragMouseListener"+                               , "MenuElement"+                               , "MenuEvent"+                               , "MenuItem"+                               , "MenuItemUI"+                               , "MenuKeyEvent"+                               , "MenuKeyListener"+                               , "MenuListener"+                               , "MenuSelectionManager"+                               , "MenuShortcut"+                               , "MessageDigest"+                               , "MessageDigestSpi"+                               , "MessageFormat"+                               , "MessageFormat.Field"+                               , "MessageProp"+                               , "MetaEventListener"+                               , "MetaMessage"+                               , "MetalBorders"+                               , "MetalBorders.ButtonBorder"+                               , "MetalBorders.Flush3DBorder"+                               , "MetalBorders.InternalFrameBorder"+                               , "MetalBorders.MenuBarBorder"+                               , "MetalBorders.MenuItemBorder"+                               , "MetalBorders.OptionDialogBorder"+                               , "MetalBorders.PaletteBorder"+                               , "MetalBorders.PopupMenuBorder"+                               , "MetalBorders.RolloverButtonBorder"+                               , "MetalBorders.ScrollPaneBorder"+                               , "MetalBorders.TableHeaderBorder"+                               , "MetalBorders.TextFieldBorder"+                               , "MetalBorders.ToggleButtonBorder"+                               , "MetalBorders.ToolBarBorder"+                               , "MetalButtonUI"+                               , "MetalCheckBoxIcon"+                               , "MetalCheckBoxUI"+                               , "MetalComboBoxButton"+                               , "MetalComboBoxEditor"+                               , "MetalComboBoxEditor.UIResource"+                               , "MetalComboBoxIcon"+                               , "MetalComboBoxUI"+                               , "MetalDesktopIconUI"+                               , "MetalFileChooserUI"+                               , "MetalIconFactory"+                               , "MetalIconFactory.FileIcon16"+                               , "MetalIconFactory.FolderIcon16"+                               , "MetalIconFactory.PaletteCloseIcon"+                               , "MetalIconFactory.TreeControlIcon"+                               , "MetalIconFactory.TreeFolderIcon"+                               , "MetalIconFactory.TreeLeafIcon"+                               , "MetalInternalFrameTitlePane"+                               , "MetalInternalFrameUI"+                               , "MetalLabelUI"+                               , "MetalLookAndFeel"+                               , "MetalMenuBarUI"+                               , "MetalPopupMenuSeparatorUI"+                               , "MetalProgressBarUI"+                               , "MetalRadioButtonUI"+                               , "MetalRootPaneUI"+                               , "MetalScrollBarUI"+                               , "MetalScrollButton"+                               , "MetalScrollPaneUI"+                               , "MetalSeparatorUI"+                               , "MetalSliderUI"+                               , "MetalSplitPaneUI"+                               , "MetalTabbedPaneUI"+                               , "MetalTextFieldUI"+                               , "MetalTheme"+                               , "MetalToggleButtonUI"+                               , "MetalToolBarUI"+                               , "MetalToolTipUI"+                               , "MetalTreeUI"+                               , "Method"+                               , "MethodDescriptor"+                               , "MidiChannel"+                               , "MidiDevice"+                               , "MidiDevice.Info"+                               , "MidiDeviceProvider"+                               , "MidiEvent"+                               , "MidiFileFormat"+                               , "MidiFileReader"+                               , "MidiFileWriter"+                               , "MidiMessage"+                               , "MidiSystem"+                               , "MidiUnavailableException"+                               , "MimeTypeParseException"+                               , "MinimalHTMLWriter"+                               , "MissingFormatArgumentException"+                               , "MissingFormatWidthException"+                               , "MissingResourceException"+                               , "Mixer"+                               , "Mixer.Info"+                               , "MixerProvider"+                               , "ModelMBean"+                               , "ModelMBeanAttributeInfo"+                               , "ModelMBeanConstructorInfo"+                               , "ModelMBeanInfo"+                               , "ModelMBeanInfoSupport"+                               , "ModelMBeanNotificationBroadcaster"+                               , "ModelMBeanNotificationInfo"+                               , "ModelMBeanOperationInfo"+                               , "ModificationItem"+                               , "Modifier"+                               , "Monitor"+                               , "MonitorMBean"+                               , "MonitorNotification"+                               , "MonitorSettingException"+                               , "MouseAdapter"+                               , "MouseDragGestureRecognizer"+                               , "MouseEvent"+                               , "MouseInfo"+                               , "MouseInputAdapter"+                               , "MouseInputListener"+                               , "MouseListener"+                               , "MouseMotionAdapter"+                               , "MouseMotionListener"+                               , "MouseWheelEvent"+                               , "MouseWheelListener"+                               , "MultiButtonUI"+                               , "MultiColorChooserUI"+                               , "MultiComboBoxUI"+                               , "MultiDesktopIconUI"+                               , "MultiDesktopPaneUI"+                               , "MultiDoc"+                               , "MultiDocPrintJob"+                               , "MultiDocPrintService"+                               , "MultiFileChooserUI"+                               , "MultiInternalFrameUI"+                               , "MultiLabelUI"+                               , "MultiListUI"+                               , "MultiLookAndFeel"+                               , "MultiMenuBarUI"+                               , "MultiMenuItemUI"+                               , "MultiOptionPaneUI"+                               , "MultiPanelUI"+                               , "MultiPixelPackedSampleModel"+                               , "MultiPopupMenuUI"+                               , "MultiProgressBarUI"+                               , "MultiRootPaneUI"+                               , "MultiScrollBarUI"+                               , "MultiScrollPaneUI"+                               , "MultiSeparatorUI"+                               , "MultiSliderUI"+                               , "MultiSpinnerUI"+                               , "MultiSplitPaneUI"+                               , "MultiTabbedPaneUI"+                               , "MultiTableHeaderUI"+                               , "MultiTableUI"+                               , "MultiTextUI"+                               , "MultiToolBarUI"+                               , "MultiToolTipUI"+                               , "MultiTreeUI"+                               , "MultiViewportUI"+                               , "MulticastSocket"+                               , "MultipleComponentProfileHelper"+                               , "MultipleComponentProfileHolder"+                               , "MultipleDocumentHandling"+                               , "MultipleMaster"+                               , "MutableAttributeSet"+                               , "MutableComboBoxModel"+                               , "MutableTreeNode"+                               , "NON_EXISTENT"+                               , "NO_IMPLEMENT"+                               , "NO_MEMORY"+                               , "NO_PERMISSION"+                               , "NO_RESOURCES"+                               , "NO_RESPONSE"+                               , "NVList"+                               , "Name"+                               , "NameAlreadyBoundException"+                               , "NameCallback"+                               , "NameClassPair"+                               , "NameComponent"+                               , "NameComponentHelper"+                               , "NameComponentHolder"+                               , "NameDynAnyPair"+                               , "NameDynAnyPairHelper"+                               , "NameDynAnyPairSeqHelper"+                               , "NameHelper"+                               , "NameHolder"+                               , "NameList"+                               , "NameNotFoundException"+                               , "NameParser"+                               , "NameValuePair"+                               , "NameValuePairHelper"+                               , "NameValuePairSeqHelper"+                               , "NamedNodeMap"+                               , "NamedValue"+                               , "NamespaceChangeListener"+                               , "NamespaceContext"+                               , "NamespaceSupport"+                               , "Naming"+                               , "NamingContext"+                               , "NamingContextExt"+                               , "NamingContextExtHelper"+                               , "NamingContextExtHolder"+                               , "NamingContextExtOperations"+                               , "NamingContextExtPOA"+                               , "NamingContextHelper"+                               , "NamingContextHolder"+                               , "NamingContextOperations"+                               , "NamingContextPOA"+                               , "NamingEnumeration"+                               , "NamingEvent"+                               , "NamingException"+                               , "NamingExceptionEvent"+                               , "NamingListener"+                               , "NamingManager"+                               , "NamingSecurityException"+                               , "NavigationFilter"+                               , "NavigationFilter.FilterBypass"+                               , "NegativeArraySizeException"+                               , "NetPermission"+                               , "NetworkInterface"+                               , "NoClassDefFoundError"+                               , "NoConnectionPendingException"+                               , "NoContext"+                               , "NoContextHelper"+                               , "NoInitialContextException"+                               , "NoPermissionException"+                               , "NoRouteToHostException"+                               , "NoServant"+                               , "NoServantHelper"+                               , "NoSuchAlgorithmException"+                               , "NoSuchAttributeException"+                               , "NoSuchElementException"+                               , "NoSuchFieldError"+                               , "NoSuchFieldException"+                               , "NoSuchMethodError"+                               , "NoSuchMethodException"+                               , "NoSuchObjectException"+                               , "NoSuchPaddingException"+                               , "NoSuchProviderException"+                               , "Node"+                               , "NodeChangeEvent"+                               , "NodeChangeListener"+                               , "NodeList"+                               , "NonReadableChannelException"+                               , "NonWritableChannelException"+                               , "NoninvertibleTransformException"+                               , "NotActiveException"+                               , "NotBoundException"+                               , "NotCompliantMBeanException"+                               , "NotContextException"+                               , "NotEmpty"+                               , "NotEmptyHelper"+                               , "NotEmptyHolder"+                               , "NotFound"+                               , "NotFoundHelper"+                               , "NotFoundHolder"+                               , "NotFoundReason"+                               , "NotFoundReasonHelper"+                               , "NotFoundReasonHolder"+                               , "NotOwnerException"+                               , "NotSerializableException"+                               , "NotYetBoundException"+                               , "NotYetConnectedException"+                               , "Notation"+                               , "Notification"+                               , "NotificationBroadcaster"+                               , "NotificationBroadcasterSupport"+                               , "NotificationEmitter"+                               , "NotificationFilter"+                               , "NotificationFilterSupport"+                               , "NotificationListener"+                               , "NotificationResult"+                               , "NullCipher"+                               , "NullPointerException"+                               , "Number"+                               , "NumberFormat"+                               , "NumberFormat.Field"+                               , "NumberFormatException"+                               , "NumberFormatter"+                               , "NumberOfDocuments"+                               , "NumberOfInterveningJobs"+                               , "NumberUp"+                               , "NumberUpSupported"+                               , "NumericShaper"+                               , "OAEPParameterSpec"+                               , "OBJECT_NOT_EXIST"+                               , "OBJ_ADAPTER"+                               , "OMGVMCID"+                               , "ORB"+                               , "ORBIdHelper"+                               , "ORBInitInfo"+                               , "ORBInitInfoOperations"+                               , "ORBInitializer"+                               , "ORBInitializerOperations"+                               , "ObjID"+                               , "Object"+                               , "ObjectAlreadyActive"+                               , "ObjectAlreadyActiveHelper"+                               , "ObjectChangeListener"+                               , "ObjectFactory"+                               , "ObjectFactoryBuilder"+                               , "ObjectHelper"+                               , "ObjectHolder"+                               , "ObjectIdHelper"+                               , "ObjectImpl"+                               , "ObjectInput"+                               , "ObjectInputStream"+                               , "ObjectInputStream.GetField"+                               , "ObjectInputValidation"+                               , "ObjectInstance"+                               , "ObjectName"+                               , "ObjectNotActive"+                               , "ObjectNotActiveHelper"+                               , "ObjectOutput"+                               , "ObjectOutputStream"+                               , "ObjectOutputStream.PutField"+                               , "ObjectReferenceFactory"+                               , "ObjectReferenceFactoryHelper"+                               , "ObjectReferenceFactoryHolder"+                               , "ObjectReferenceTemplate"+                               , "ObjectReferenceTemplateHelper"+                               , "ObjectReferenceTemplateHolder"+                               , "ObjectReferenceTemplateSeqHelper"+                               , "ObjectReferenceTemplateSeqHolder"+                               , "ObjectStreamClass"+                               , "ObjectStreamConstants"+                               , "ObjectStreamException"+                               , "ObjectStreamField"+                               , "ObjectView"+                               , "Observable"+                               , "Observer"+                               , "OceanTheme"+                               , "OctetSeqHelper"+                               , "OctetSeqHolder"+                               , "Oid"+                               , "OpenDataException"+                               , "OpenMBeanAttributeInfo"+                               , "OpenMBeanAttributeInfoSupport"+                               , "OpenMBeanConstructorInfo"+                               , "OpenMBeanConstructorInfoSupport"+                               , "OpenMBeanInfo"+                               , "OpenMBeanInfoSupport"+                               , "OpenMBeanOperationInfo"+                               , "OpenMBeanOperationInfoSupport"+                               , "OpenMBeanParameterInfo"+                               , "OpenMBeanParameterInfoSupport"+                               , "OpenType"+                               , "OperatingSystemMXBean"+                               , "Operation"+                               , "OperationNotSupportedException"+                               , "OperationsException"+                               , "Option"+                               , "OptionPaneUI"+                               , "OptionalDataException"+                               , "OrientationRequested"+                               , "OutOfMemoryError"+                               , "OutputDeviceAssigned"+                               , "OutputKeys"+                               , "OutputStream"+                               , "OutputStreamWriter"+                               , "OverlappingFileLockException"+                               , "OverlayLayout"+                               , "Override"+                               , "Owner"+                               , "PBEKey"+                               , "PBEKeySpec"+                               , "PBEParameterSpec"+                               , "PDLOverrideSupported"+                               , "PERSIST_STORE"+                               , "PKCS8EncodedKeySpec"+                               , "PKIXBuilderParameters"+                               , "PKIXCertPathBuilderResult"+                               , "PKIXCertPathChecker"+                               , "PKIXCertPathValidatorResult"+                               , "PKIXParameters"+                               , "POA"+                               , "POAHelper"+                               , "POAManager"+                               , "POAManagerOperations"+                               , "POAOperations"+                               , "PRIVATE_MEMBER"+                               , "PSSParameterSpec"+                               , "PSource"+                               , "PSource.PSpecified"+                               , "PUBLIC_MEMBER"+                               , "Pack200"+                               , "Pack200.Packer"+                               , "Pack200.Unpacker"+                               , "Package"+                               , "PackedColorModel"+                               , "PageAttributes"+                               , "PageAttributes.ColorType"+                               , "PageAttributes.MediaType"+                               , "PageAttributes.OrientationRequestedType"+                               , "PageAttributes.OriginType"+                               , "PageAttributes.PrintQualityType"+                               , "PageFormat"+                               , "PageRanges"+                               , "Pageable"+                               , "PagedResultsControl"+                               , "PagedResultsResponseControl"+                               , "PagesPerMinute"+                               , "PagesPerMinuteColor"+                               , "Paint"+                               , "PaintContext"+                               , "PaintEvent"+                               , "Panel"+                               , "PanelUI"+                               , "Paper"+                               , "ParagraphView"+                               , "Parameter"+                               , "ParameterBlock"+                               , "ParameterDescriptor"+                               , "ParameterMetaData"+                               , "ParameterMode"+                               , "ParameterModeHelper"+                               , "ParameterModeHolder"+                               , "ParameterizedType"+                               , "ParseException"+                               , "ParsePosition"+                               , "Parser"+                               , "ParserAdapter"+                               , "ParserConfigurationException"+                               , "ParserDelegator"+                               , "ParserFactory"+                               , "PartialResultException"+                               , "PasswordAuthentication"+                               , "PasswordCallback"+                               , "PasswordView"+                               , "Patch"+                               , "PathIterator"+                               , "Pattern"+                               , "PatternSyntaxException"+                               , "Permission"+                               , "PermissionCollection"+                               , "Permissions"+                               , "PersistenceDelegate"+                               , "PersistentMBean"+                               , "PhantomReference"+                               , "Pipe"+                               , "Pipe.SinkChannel"+                               , "Pipe.SourceChannel"+                               , "PipedInputStream"+                               , "PipedOutputStream"+                               , "PipedReader"+                               , "PipedWriter"+                               , "PixelGrabber"+                               , "PixelInterleavedSampleModel"+                               , "PlainDocument"+                               , "PlainView"+                               , "Point"+                               , "Point2D"+                               , "Point2D.Double"+                               , "Point2D.Float"+                               , "PointerInfo"+                               , "Policy"+                               , "PolicyError"+                               , "PolicyErrorCodeHelper"+                               , "PolicyErrorHelper"+                               , "PolicyErrorHolder"+                               , "PolicyFactory"+                               , "PolicyFactoryOperations"+                               , "PolicyHelper"+                               , "PolicyHolder"+                               , "PolicyListHelper"+                               , "PolicyListHolder"+                               , "PolicyNode"+                               , "PolicyOperations"+                               , "PolicyQualifierInfo"+                               , "PolicyTypeHelper"+                               , "Polygon"+                               , "PooledConnection"+                               , "Popup"+                               , "PopupFactory"+                               , "PopupMenu"+                               , "PopupMenuEvent"+                               , "PopupMenuListener"+                               , "PopupMenuUI"+                               , "Port"+                               , "Port.Info"+                               , "PortUnreachableException"+                               , "PortableRemoteObject"+                               , "PortableRemoteObjectDelegate"+                               , "Position"+                               , "Position.Bias"+                               , "Predicate"+                               , "PreferenceChangeEvent"+                               , "PreferenceChangeListener"+                               , "Preferences"+                               , "PreferencesFactory"+                               , "PreparedStatement"+                               , "PresentationDirection"+                               , "Principal"+                               , "PrincipalHolder"+                               , "PrintEvent"+                               , "PrintException"+                               , "PrintGraphics"+                               , "PrintJob"+                               , "PrintJobAdapter"+                               , "PrintJobAttribute"+                               , "PrintJobAttributeEvent"+                               , "PrintJobAttributeListener"+                               , "PrintJobAttributeSet"+                               , "PrintJobEvent"+                               , "PrintJobListener"+                               , "PrintQuality"+                               , "PrintRequestAttribute"+                               , "PrintRequestAttributeSet"+                               , "PrintService"+                               , "PrintServiceAttribute"+                               , "PrintServiceAttributeEvent"+                               , "PrintServiceAttributeListener"+                               , "PrintServiceAttributeSet"+                               , "PrintServiceLookup"+                               , "PrintStream"+                               , "PrintWriter"+                               , "Printable"+                               , "PrinterAbortException"+                               , "PrinterException"+                               , "PrinterGraphics"+                               , "PrinterIOException"+                               , "PrinterInfo"+                               , "PrinterIsAcceptingJobs"+                               , "PrinterJob"+                               , "PrinterLocation"+                               , "PrinterMakeAndModel"+                               , "PrinterMessageFromOperator"+                               , "PrinterMoreInfo"+                               , "PrinterMoreInfoManufacturer"+                               , "PrinterName"+                               , "PrinterResolution"+                               , "PrinterState"+                               , "PrinterStateReason"+                               , "PrinterStateReasons"+                               , "PrinterURI"+                               , "PriorityBlockingQueue"+                               , "PriorityQueue"+                               , "PrivateClassLoader"+                               , "PrivateCredentialPermission"+                               , "PrivateKey"+                               , "PrivateMLet"+                               , "PrivilegedAction"+                               , "PrivilegedActionException"+                               , "PrivilegedExceptionAction"+                               , "Process"+                               , "ProcessBuilder"+                               , "ProcessingInstruction"+                               , "ProfileDataException"+                               , "ProfileIdHelper"+                               , "ProgressBarUI"+                               , "ProgressMonitor"+                               , "ProgressMonitorInputStream"+                               , "Properties"+                               , "PropertyChangeEvent"+                               , "PropertyChangeListener"+                               , "PropertyChangeListenerProxy"+                               , "PropertyChangeSupport"+                               , "PropertyDescriptor"+                               , "PropertyEditor"+                               , "PropertyEditorManager"+                               , "PropertyEditorSupport"+                               , "PropertyPermission"+                               , "PropertyResourceBundle"+                               , "PropertyVetoException"+                               , "ProtectionDomain"+                               , "ProtocolException"+                               , "Provider"+                               , "Provider.Service"+                               , "ProviderException"+                               , "Proxy"+                               , "Proxy.Type"+                               , "ProxySelector"+                               , "PublicKey"+                               , "PushbackInputStream"+                               , "PushbackReader"+                               , "QName"+                               , "QuadCurve2D"+                               , "QuadCurve2D.Double"+                               , "QuadCurve2D.Float"+                               , "Query"+                               , "QueryEval"+                               , "QueryExp"+                               , "Queue"+                               , "QueuedJobCount"+                               , "RC2ParameterSpec"+                               , "RC5ParameterSpec"+                               , "REBIND"+                               , "REQUEST_PROCESSING_POLICY_ID"+                               , "RGBImageFilter"+                               , "RMIClassLoader"+                               , "RMIClassLoaderSpi"+                               , "RMIClientSocketFactory"+                               , "RMIConnection"+                               , "RMIConnectionImpl"+                               , "RMIConnectionImpl_Stub"+                               , "RMIConnector"+                               , "RMIConnectorServer"+                               , "RMICustomMaxStreamFormat"+                               , "RMIFailureHandler"+                               , "RMIIIOPServerImpl"+                               , "RMIJRMPServerImpl"+                               , "RMISecurityException"+                               , "RMISecurityManager"+                               , "RMIServer"+                               , "RMIServerImpl"+                               , "RMIServerImpl_Stub"+                               , "RMIServerSocketFactory"+                               , "RMISocketFactory"+                               , "RSAKey"+                               , "RSAKeyGenParameterSpec"+                               , "RSAMultiPrimePrivateCrtKey"+                               , "RSAMultiPrimePrivateCrtKeySpec"+                               , "RSAOtherPrimeInfo"+                               , "RSAPrivateCrtKey"+                               , "RSAPrivateCrtKeySpec"+                               , "RSAPrivateKey"+                               , "RSAPrivateKeySpec"+                               , "RSAPublicKey"+                               , "RSAPublicKeySpec"+                               , "RTFEditorKit"+                               , "Random"+                               , "RandomAccess"+                               , "RandomAccessFile"+                               , "Raster"+                               , "RasterFormatException"+                               , "RasterOp"+                               , "Rdn"+                               , "ReadOnlyBufferException"+                               , "ReadWriteLock"+                               , "Readable"+                               , "ReadableByteChannel"+                               , "Reader"+                               , "RealmCallback"+                               , "RealmChoiceCallback"+                               , "Receiver"+                               , "Rectangle"+                               , "Rectangle2D"+                               , "Rectangle2D.Double"+                               , "Rectangle2D.Float"+                               , "RectangularShape"+                               , "ReentrantLock"+                               , "ReentrantReadWriteLock"+                               , "ReentrantReadWriteLock.ReadLock"+                               , "ReentrantReadWriteLock.WriteLock"+                               , "Ref"+                               , "RefAddr"+                               , "Reference"+                               , "ReferenceQueue"+                               , "ReferenceUriSchemesSupported"+                               , "Referenceable"+                               , "ReferralException"+                               , "ReflectPermission"+                               , "ReflectionException"+                               , "RefreshFailedException"+                               , "Refreshable"+                               , "Region"+                               , "RegisterableService"+                               , "Registry"+                               , "RegistryHandler"+                               , "RejectedExecutionException"+                               , "RejectedExecutionHandler"+                               , "Relation"+                               , "RelationException"+                               , "RelationNotFoundException"+                               , "RelationNotification"+                               , "RelationService"+                               , "RelationServiceMBean"+                               , "RelationServiceNotRegisteredException"+                               , "RelationSupport"+                               , "RelationSupportMBean"+                               , "RelationType"+                               , "RelationTypeNotFoundException"+                               , "RelationTypeSupport"+                               , "RemarshalException"+                               , "Remote"+                               , "RemoteCall"+                               , "RemoteException"+                               , "RemoteObject"+                               , "RemoteObjectInvocationHandler"+                               , "RemoteRef"+                               , "RemoteServer"+                               , "RemoteStub"+                               , "RenderContext"+                               , "RenderableImage"+                               , "RenderableImageOp"+                               , "RenderableImageProducer"+                               , "RenderedImage"+                               , "RenderedImageFactory"+                               , "Renderer"+                               , "RenderingHints"+                               , "RenderingHints.Key"+                               , "RepaintManager"+                               , "ReplicateScaleFilter"+                               , "RepositoryIdHelper"+                               , "Request"+                               , "RequestInfo"+                               , "RequestInfoOperations"+                               , "RequestProcessingPolicy"+                               , "RequestProcessingPolicyOperations"+                               , "RequestProcessingPolicyValue"+                               , "RequestingUserName"+                               , "RequiredModelMBean"+                               , "RescaleOp"+                               , "ResolutionSyntax"+                               , "ResolveResult"+                               , "Resolver"+                               , "ResourceBundle"+                               , "ResponseCache"+                               , "ResponseHandler"+                               , "Result"+                               , "ResultSet"+                               , "ResultSetMetaData"+                               , "Retention"+                               , "RetentionPolicy"+                               , "ReverbType"+                               , "Robot"+                               , "Role"+                               , "RoleInfo"+                               , "RoleInfoNotFoundException"+                               , "RoleList"+                               , "RoleNotFoundException"+                               , "RoleResult"+                               , "RoleStatus"+                               , "RoleUnresolved"+                               , "RoleUnresolvedList"+                               , "RootPaneContainer"+                               , "RootPaneUI"+                               , "RoundRectangle2D"+                               , "RoundRectangle2D.Double"+                               , "RoundRectangle2D.Float"+                               , "RoundingMode"+                               , "RowMapper"+                               , "RowSet"+                               , "RowSetEvent"+                               , "RowSetInternal"+                               , "RowSetListener"+                               , "RowSetMetaData"+                               , "RowSetMetaDataImpl"+                               , "RowSetReader"+                               , "RowSetWarning"+                               , "RowSetWriter"+                               , "RuleBasedCollator"+                               , "RunTime"+                               , "RunTimeOperations"+                               , "Runnable"+                               , "Runtime"+                               , "RuntimeErrorException"+                               , "RuntimeException"+                               , "RuntimeMBeanException"+                               , "RuntimeMXBean"+                               , "RuntimeOperationsException"+                               , "RuntimePermission"+                               , "SAXException"+                               , "SAXNotRecognizedException"+                               , "SAXNotSupportedException"+                               , "SAXParseException"+                               , "SAXParser"+                               , "SAXParserFactory"+                               , "SAXResult"+                               , "SAXSource"+                               , "SAXTransformerFactory"+                               , "SERVANT_RETENTION_POLICY_ID"+                               , "SQLData"+                               , "SQLException"+                               , "SQLInput"+                               , "SQLInputImpl"+                               , "SQLOutput"+                               , "SQLOutputImpl"+                               , "SQLPermission"+                               , "SQLWarning"+                               , "SSLContext"+                               , "SSLContextSpi"+                               , "SSLEngine"+                               , "SSLEngineResult"+                               , "SSLEngineResult.HandshakeStatus"+                               , "SSLEngineResult.Status"+                               , "SSLException"+                               , "SSLHandshakeException"+                               , "SSLKeyException"+                               , "SSLPeerUnverifiedException"+                               , "SSLPermission"+                               , "SSLProtocolException"+                               , "SSLServerSocket"+                               , "SSLServerSocketFactory"+                               , "SSLSession"+                               , "SSLSessionBindingEvent"+                               , "SSLSessionBindingListener"+                               , "SSLSessionContext"+                               , "SSLSocket"+                               , "SSLSocketFactory"+                               , "SUCCESSFUL"+                               , "SYNC_WITH_TRANSPORT"+                               , "SYSTEM_EXCEPTION"+                               , "SampleModel"+                               , "Sasl"+                               , "SaslClient"+                               , "SaslClientFactory"+                               , "SaslException"+                               , "SaslServer"+                               , "SaslServerFactory"+                               , "Savepoint"+                               , "Scanner"+                               , "ScatteringByteChannel"+                               , "ScheduledExecutorService"+                               , "ScheduledFuture"+                               , "ScheduledThreadPoolExecutor"+                               , "Schema"+                               , "SchemaFactory"+                               , "SchemaFactoryLoader"+                               , "SchemaViolationException"+                               , "ScrollBarUI"+                               , "ScrollPane"+                               , "ScrollPaneAdjustable"+                               , "ScrollPaneConstants"+                               , "ScrollPaneLayout"+                               , "ScrollPaneLayout.UIResource"+                               , "ScrollPaneUI"+                               , "Scrollable"+                               , "Scrollbar"+                               , "SealedObject"+                               , "SearchControls"+                               , "SearchResult"+                               , "SecretKey"+                               , "SecretKeyFactory"+                               , "SecretKeyFactorySpi"+                               , "SecretKeySpec"+                               , "SecureCacheResponse"+                               , "SecureClassLoader"+                               , "SecureRandom"+                               , "SecureRandomSpi"+                               , "Security"+                               , "SecurityException"+                               , "SecurityManager"+                               , "SecurityPermission"+                               , "Segment"+                               , "SelectableChannel"+                               , "SelectionKey"+                               , "Selector"+                               , "SelectorProvider"+                               , "Semaphore"+                               , "SeparatorUI"+                               , "Sequence"+                               , "SequenceInputStream"+                               , "Sequencer"+                               , "Sequencer.SyncMode"+                               , "SerialArray"+                               , "SerialBlob"+                               , "SerialClob"+                               , "SerialDatalink"+                               , "SerialException"+                               , "SerialJavaObject"+                               , "SerialRef"+                               , "SerialStruct"+                               , "Serializable"+                               , "SerializablePermission"+                               , "Servant"+                               , "ServantActivator"+                               , "ServantActivatorHelper"+                               , "ServantActivatorOperations"+                               , "ServantActivatorPOA"+                               , "ServantAlreadyActive"+                               , "ServantAlreadyActiveHelper"+                               , "ServantLocator"+                               , "ServantLocatorHelper"+                               , "ServantLocatorOperations"+                               , "ServantLocatorPOA"+                               , "ServantManager"+                               , "ServantManagerOperations"+                               , "ServantNotActive"+                               , "ServantNotActiveHelper"+                               , "ServantObject"+                               , "ServantRetentionPolicy"+                               , "ServantRetentionPolicyOperations"+                               , "ServantRetentionPolicyValue"+                               , "ServerCloneException"+                               , "ServerError"+                               , "ServerException"+                               , "ServerIdHelper"+                               , "ServerNotActiveException"+                               , "ServerRef"+                               , "ServerRequest"+                               , "ServerRequestInfo"+                               , "ServerRequestInfoOperations"+                               , "ServerRequestInterceptor"+                               , "ServerRequestInterceptorOperations"+                               , "ServerRuntimeException"+                               , "ServerSocket"+                               , "ServerSocketChannel"+                               , "ServerSocketFactory"+                               , "ServiceContext"+                               , "ServiceContextHelper"+                               , "ServiceContextHolder"+                               , "ServiceContextListHelper"+                               , "ServiceContextListHolder"+                               , "ServiceDetail"+                               , "ServiceDetailHelper"+                               , "ServiceIdHelper"+                               , "ServiceInformation"+                               , "ServiceInformationHelper"+                               , "ServiceInformationHolder"+                               , "ServiceNotFoundException"+                               , "ServicePermission"+                               , "ServiceRegistry"+                               , "ServiceRegistry.Filter"+                               , "ServiceUI"+                               , "ServiceUIFactory"+                               , "ServiceUnavailableException"+                               , "Set"+                               , "SetOfIntegerSyntax"+                               , "SetOverrideType"+                               , "SetOverrideTypeHelper"+                               , "Severity"+                               , "Shape"+                               , "ShapeGraphicAttribute"+                               , "SheetCollate"+                               , "Short"+                               , "ShortBuffer"+                               , "ShortBufferException"+                               , "ShortHolder"+                               , "ShortLookupTable"+                               , "ShortMessage"+                               , "ShortSeqHelper"+                               , "ShortSeqHolder"+                               , "Sides"+                               , "Signature"+                               , "SignatureException"+                               , "SignatureSpi"+                               , "SignedObject"+                               , "Signer"+                               , "SimpleAttributeSet"+                               , "SimpleBeanInfo"+                               , "SimpleDateFormat"+                               , "SimpleDoc"+                               , "SimpleFormatter"+                               , "SimpleTimeZone"+                               , "SimpleType"+                               , "SinglePixelPackedSampleModel"+                               , "SingleSelectionModel"+                               , "Size2DSyntax"+                               , "SizeLimitExceededException"+                               , "SizeRequirements"+                               , "SizeSequence"+                               , "Skeleton"+                               , "SkeletonMismatchException"+                               , "SkeletonNotFoundException"+                               , "SliderUI"+                               , "Socket"+                               , "SocketAddress"+                               , "SocketChannel"+                               , "SocketException"+                               , "SocketFactory"+                               , "SocketHandler"+                               , "SocketImpl"+                               , "SocketImplFactory"+                               , "SocketOptions"+                               , "SocketPermission"+                               , "SocketSecurityException"+                               , "SocketTimeoutException"+                               , "SoftBevelBorder"+                               , "SoftReference"+                               , "SortControl"+                               , "SortKey"+                               , "SortResponseControl"+                               , "SortedMap"+                               , "SortedSet"+                               , "SortingFocusTraversalPolicy"+                               , "Soundbank"+                               , "SoundbankReader"+                               , "SoundbankResource"+                               , "Source"+                               , "SourceDataLine"+                               , "SourceLocator"+                               , "SpinnerDateModel"+                               , "SpinnerListModel"+                               , "SpinnerModel"+                               , "SpinnerNumberModel"+                               , "SpinnerUI"+                               , "SplitPaneUI"+                               , "Spring"+                               , "SpringLayout"+                               , "SpringLayout.Constraints"+                               , "SslRMIClientSocketFactory"+                               , "SslRMIServerSocketFactory"+                               , "Stack"+                               , "StackOverflowError"+                               , "StackTraceElement"+                               , "StandardMBean"+                               , "StartTlsRequest"+                               , "StartTlsResponse"+                               , "State"+                               , "StateEdit"+                               , "StateEditable"+                               , "StateFactory"+                               , "Statement"+                               , "StreamCorruptedException"+                               , "StreamHandler"+                               , "StreamPrintService"+                               , "StreamPrintServiceFactory"+                               , "StreamResult"+                               , "StreamSource"+                               , "StreamTokenizer"+                               , "Streamable"+                               , "StreamableValue"+                               , "StrictMath"+                               , "String"+                               , "StringBuffer"+                               , "StringBufferInputStream"+                               , "StringBuilder"+                               , "StringCharacterIterator"+                               , "StringContent"+                               , "StringHolder"+                               , "StringIndexOutOfBoundsException"+                               , "StringMonitor"+                               , "StringMonitorMBean"+                               , "StringNameHelper"+                               , "StringReader"+                               , "StringRefAddr"+                               , "StringSelection"+                               , "StringSeqHelper"+                               , "StringSeqHolder"+                               , "StringTokenizer"+                               , "StringValueExp"+                               , "StringValueHelper"+                               , "StringWriter"+                               , "Stroke"+                               , "Struct"+                               , "StructMember"+                               , "StructMemberHelper"+                               , "Stub"+                               , "StubDelegate"+                               , "StubNotFoundException"+                               , "Style"+                               , "StyleConstants"+                               , "StyleConstants.CharacterConstants"+                               , "StyleConstants.ColorConstants"+                               , "StyleConstants.FontConstants"+                               , "StyleConstants.ParagraphConstants"+                               , "StyleContext"+                               , "StyleSheet"+                               , "StyleSheet.BoxPainter"+                               , "StyleSheet.ListPainter"+                               , "StyledDocument"+                               , "StyledEditorKit"+                               , "StyledEditorKit.AlignmentAction"+                               , "StyledEditorKit.BoldAction"+                               , "StyledEditorKit.FontFamilyAction"+                               , "StyledEditorKit.FontSizeAction"+                               , "StyledEditorKit.ForegroundAction"+                               , "StyledEditorKit.ItalicAction"+                               , "StyledEditorKit.StyledTextAction"+                               , "StyledEditorKit.UnderlineAction"+                               , "Subject"+                               , "SubjectDelegationPermission"+                               , "SubjectDomainCombiner"+                               , "SupportedValuesAttribute"+                               , "SuppressWarnings"+                               , "SwingConstants"+                               , "SwingPropertyChangeSupport"+                               , "SwingUtilities"+                               , "SyncFactory"+                               , "SyncFactoryException"+                               , "SyncFailedException"+                               , "SyncProvider"+                               , "SyncProviderException"+                               , "SyncResolver"+                               , "SyncScopeHelper"+                               , "SynchronousQueue"+                               , "SynthConstants"+                               , "SynthContext"+                               , "SynthGraphicsUtils"+                               , "SynthLookAndFeel"+                               , "SynthPainter"+                               , "SynthStyle"+                               , "SynthStyleFactory"+                               , "Synthesizer"+                               , "SysexMessage"+                               , "System"+                               , "SystemColor"+                               , "SystemException"+                               , "SystemFlavorMap"+                               , "TAG_ALTERNATE_IIOP_ADDRESS"+                               , "TAG_CODE_SETS"+                               , "TAG_INTERNET_IOP"+                               , "TAG_JAVA_CODEBASE"+                               , "TAG_MULTIPLE_COMPONENTS"+                               , "TAG_ORB_TYPE"+                               , "TAG_POLICIES"+                               , "TAG_RMI_CUSTOM_MAX_STREAM_FORMAT"+                               , "TCKind"+                               , "THREAD_POLICY_ID"+                               , "TIMEOUT"+                               , "TRANSACTION_MODE"+                               , "TRANSACTION_REQUIRED"+                               , "TRANSACTION_ROLLEDBACK"+                               , "TRANSACTION_UNAVAILABLE"+                               , "TRANSIENT"+                               , "TRANSPORT_RETRY"+                               , "TabExpander"+                               , "TabSet"+                               , "TabStop"+                               , "TabableView"+                               , "TabbedPaneUI"+                               , "TableCellEditor"+                               , "TableCellRenderer"+                               , "TableColumn"+                               , "TableColumnModel"+                               , "TableColumnModelEvent"+                               , "TableColumnModelListener"+                               , "TableHeaderUI"+                               , "TableModel"+                               , "TableModelEvent"+                               , "TableModelListener"+                               , "TableUI"+                               , "TableView"+                               , "TabularData"+                               , "TabularDataSupport"+                               , "TabularType"+                               , "TagElement"+                               , "TaggedComponent"+                               , "TaggedComponentHelper"+                               , "TaggedComponentHolder"+                               , "TaggedProfile"+                               , "TaggedProfileHelper"+                               , "TaggedProfileHolder"+                               , "Target"+                               , "TargetDataLine"+                               , "TargetedNotification"+                               , "Templates"+                               , "TemplatesHandler"+                               , "Text"+                               , "TextAction"+                               , "TextArea"+                               , "TextAttribute"+                               , "TextComponent"+                               , "TextEvent"+                               , "TextField"+                               , "TextHitInfo"+                               , "TextInputCallback"+                               , "TextLayout"+                               , "TextLayout.CaretPolicy"+                               , "TextListener"+                               , "TextMeasurer"+                               , "TextOutputCallback"+                               , "TextSyntax"+                               , "TextUI"+                               , "TexturePaint"+                               , "Thread"+                               , "Thread.State"+                               , "Thread.UncaughtExceptionHandler"+                               , "ThreadDeath"+                               , "ThreadFactory"+                               , "ThreadGroup"+                               , "ThreadInfo"+                               , "ThreadLocal"+                               , "ThreadMXBean"+                               , "ThreadPolicy"+                               , "ThreadPolicyOperations"+                               , "ThreadPolicyValue"+                               , "ThreadPoolExecutor"+                               , "ThreadPoolExecutor.AbortPolicy"+                               , "ThreadPoolExecutor.CallerRunsPolicy"+                               , "ThreadPoolExecutor.DiscardOldestPolicy"+                               , "ThreadPoolExecutor.DiscardPolicy"+                               , "Throwable"+                               , "Tie"+                               , "TileObserver"+                               , "Time"+                               , "TimeLimitExceededException"+                               , "TimeUnit"+                               , "TimeZone"+                               , "TimeoutException"+                               , "Timer"+                               , "TimerAlarmClockNotification"+                               , "TimerMBean"+                               , "TimerNotification"+                               , "TimerTask"+                               , "Timestamp"+                               , "TitledBorder"+                               , "TooManyListenersException"+                               , "ToolBarUI"+                               , "ToolTipManager"+                               , "ToolTipUI"+                               , "Toolkit"+                               , "Track"+                               , "TransactionRequiredException"+                               , "TransactionRolledbackException"+                               , "TransactionService"+                               , "TransactionalWriter"+                               , "TransferHandler"+                               , "Transferable"+                               , "TransformAttribute"+                               , "Transformer"+                               , "TransformerConfigurationException"+                               , "TransformerException"+                               , "TransformerFactory"+                               , "TransformerFactoryConfigurationError"+                               , "TransformerHandler"+                               , "Transmitter"+                               , "Transparency"+                               , "TreeCellEditor"+                               , "TreeCellRenderer"+                               , "TreeExpansionEvent"+                               , "TreeExpansionListener"+                               , "TreeMap"+                               , "TreeModel"+                               , "TreeModelEvent"+                               , "TreeModelListener"+                               , "TreeNode"+                               , "TreePath"+                               , "TreeSelectionEvent"+                               , "TreeSelectionListener"+                               , "TreeSelectionModel"+                               , "TreeSet"+                               , "TreeUI"+                               , "TreeWillExpandListener"+                               , "TrustAnchor"+                               , "TrustManager"+                               , "TrustManagerFactory"+                               , "TrustManagerFactorySpi"+                               , "Type"+                               , "TypeCode"+                               , "TypeCodeHolder"+                               , "TypeInfo"+                               , "TypeInfoProvider"+                               , "TypeMismatch"+                               , "TypeMismatchHelper"+                               , "TypeNotPresentException"+                               , "TypeVariable"+                               , "Types"+                               , "UID"+                               , "UIDefaults"+                               , "UIDefaults.ActiveValue"+                               , "UIDefaults.LazyInputMap"+                               , "UIDefaults.LazyValue"+                               , "UIDefaults.ProxyLazyValue"+                               , "UIManager"+                               , "UIManager.LookAndFeelInfo"+                               , "UIResource"+                               , "ULongLongSeqHelper"+                               , "ULongLongSeqHolder"+                               , "ULongSeqHelper"+                               , "ULongSeqHolder"+                               , "UNKNOWN"+                               , "UNSUPPORTED_POLICY"+                               , "UNSUPPORTED_POLICY_VALUE"+                               , "URI"+                               , "URIException"+                               , "URIResolver"+                               , "URISyntax"+                               , "URISyntaxException"+                               , "URL"+                               , "URLClassLoader"+                               , "URLConnection"+                               , "URLDecoder"+                               , "URLEncoder"+                               , "URLStreamHandler"+                               , "URLStreamHandlerFactory"+                               , "URLStringHelper"+                               , "USER_EXCEPTION"+                               , "UShortSeqHelper"+                               , "UShortSeqHolder"+                               , "UTFDataFormatException"+                               , "UUID"+                               , "UndeclaredThrowableException"+                               , "UndoManager"+                               , "UndoableEdit"+                               , "UndoableEditEvent"+                               , "UndoableEditListener"+                               , "UndoableEditSupport"+                               , "UnexpectedException"+                               , "UnicastRemoteObject"+                               , "UnionMember"+                               , "UnionMemberHelper"+                               , "UnknownEncoding"+                               , "UnknownEncodingHelper"+                               , "UnknownError"+                               , "UnknownException"+                               , "UnknownFormatConversionException"+                               , "UnknownFormatFlagsException"+                               , "UnknownGroupException"+                               , "UnknownHostException"+                               , "UnknownObjectException"+                               , "UnknownServiceException"+                               , "UnknownUserException"+                               , "UnknownUserExceptionHelper"+                               , "UnknownUserExceptionHolder"+                               , "UnmappableCharacterException"+                               , "UnmarshalException"+                               , "UnmodifiableClassException"+                               , "UnmodifiableSetException"+                               , "UnrecoverableEntryException"+                               , "UnrecoverableKeyException"+                               , "Unreferenced"+                               , "UnresolvedAddressException"+                               , "UnresolvedPermission"+                               , "UnsatisfiedLinkError"+                               , "UnsolicitedNotification"+                               , "UnsolicitedNotificationEvent"+                               , "UnsolicitedNotificationListener"+                               , "UnsupportedAddressTypeException"+                               , "UnsupportedAudioFileException"+                               , "UnsupportedCallbackException"+                               , "UnsupportedCharsetException"+                               , "UnsupportedClassVersionError"+                               , "UnsupportedEncodingException"+                               , "UnsupportedFlavorException"+                               , "UnsupportedLookAndFeelException"+                               , "UnsupportedOperationException"+                               , "UserDataHandler"+                               , "UserException"+                               , "Util"+                               , "UtilDelegate"+                               , "Utilities"+                               , "VMID"+                               , "VM_ABSTRACT"+                               , "VM_CUSTOM"+                               , "VM_NONE"+                               , "VM_TRUNCATABLE"+                               , "Validator"+                               , "ValidatorHandler"+                               , "ValueBase"+                               , "ValueBaseHelper"+                               , "ValueBaseHolder"+                               , "ValueExp"+                               , "ValueFactory"+                               , "ValueHandler"+                               , "ValueHandlerMultiFormat"+                               , "ValueInputStream"+                               , "ValueMember"+                               , "ValueMemberHelper"+                               , "ValueOutputStream"+                               , "VariableHeightLayoutCache"+                               , "Vector"+                               , "VerifyError"+                               , "VersionSpecHelper"+                               , "VetoableChangeListener"+                               , "VetoableChangeListenerProxy"+                               , "VetoableChangeSupport"+                               , "View"+                               , "ViewFactory"+                               , "ViewportLayout"+                               , "ViewportUI"+                               , "VirtualMachineError"+                               , "Visibility"+                               , "VisibilityHelper"+                               , "VoiceStatus"+                               , "Void"+                               , "VolatileImage"+                               , "WCharSeqHelper"+                               , "WCharSeqHolder"+                               , "WStringSeqHelper"+                               , "WStringSeqHolder"+                               , "WStringValueHelper"+                               , "WeakHashMap"+                               , "WeakReference"+                               , "WebRowSet"+                               , "WildcardType"+                               , "Window"+                               , "WindowAdapter"+                               , "WindowConstants"+                               , "WindowEvent"+                               , "WindowFocusListener"+                               , "WindowListener"+                               , "WindowStateListener"+                               , "WrappedPlainView"+                               , "WritableByteChannel"+                               , "WritableRaster"+                               , "WritableRenderedImage"+                               , "WriteAbortedException"+                               , "Writer"+                               , "WrongAdapter"+                               , "WrongAdapterHelper"+                               , "WrongPolicy"+                               , "WrongPolicyHelper"+                               , "WrongTransaction"+                               , "WrongTransactionHelper"+                               , "WrongTransactionHolder"+                               , "X500Principal"+                               , "X500PrivateCredential"+                               , "X509CRL"+                               , "X509CRLEntry"+                               , "X509CRLSelector"+                               , "X509CertSelector"+                               , "X509Certificate"+                               , "X509EncodedKeySpec"+                               , "X509ExtendedKeyManager"+                               , "X509Extension"+                               , "X509KeyManager"+                               , "X509TrustManager"+                               , "XAConnection"+                               , "XADataSource"+                               , "XAException"+                               , "XAResource"+                               , "XMLConstants"+                               , "XMLDecoder"+                               , "XMLEncoder"+                               , "XMLFilter"+                               , "XMLFilterImpl"+                               , "XMLFormatter"+                               , "XMLGregorianCalendar"+                               , "XMLParseException"+                               , "XMLReader"+                               , "XMLReaderAdapter"+                               , "XMLReaderFactory"+                               , "XPath"+                               , "XPathConstants"+                               , "XPathException"+                               , "XPathExpression"+                               , "XPathExpressionException"+                               , "XPathFactory"+                               , "XPathFactoryConfigurationException"+                               , "XPathFunction"+                               , "XPathFunctionException"+                               , "XPathFunctionResolver"+                               , "XPathVariableResolver"+                               , "Xid"+                               , "XmlReader"+                               , "XmlWriter"+                               , "ZipEntry"+                               , "ZipException"+                               , "ZipFile"+                               , "ZipInputStream"+                               , "ZipOutputStream"+                               , "ZoneView"+                               , "_BindingIteratorImplBase"+                               , "_BindingIteratorStub"+                               , "_DynAnyFactoryStub"+                               , "_DynAnyStub"+                               , "_DynArrayStub"+                               , "_DynEnumStub"+                               , "_DynFixedStub"+                               , "_DynSequenceStub"+                               , "_DynStructStub"+                               , "_DynUnionStub"+                               , "_DynValueStub"+                               , "_IDLTypeStub"+                               , "_NamingContextExtStub"+                               , "_NamingContextImplBase"+                               , "_NamingContextStub"+                               , "_PolicyStub"+                               , "_Remote_Stub"+                               , "_ServantActivatorStub"+                               , "_ServantLocatorStub"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Actor"+                               , "ActorProxy"+                               , "ActorTask"+                               , "ActorThread"+                               , "AllRef"+                               , "Any"+                               , "AnyRef"+                               , "Application"+                               , "AppliedType"+                               , "Array"+                               , "ArrayBuffer"+                               , "Attribute"+                               , "BoxedArray"+                               , "BoxedBooleanArray"+                               , "BoxedByteArray"+                               , "BoxedCharArray"+                               , "Buffer"+                               , "BufferedIterator"+                               , "Char"+                               , "Console"+                               , "Enumeration"+                               , "Fluid"+                               , "Function"+                               , "IScheduler"+                               , "ImmutableMapAdaptor"+                               , "ImmutableSetAdaptor"+                               , "Int"+                               , "Iterable"+                               , "List"+                               , "ListBuffer"+                               , "None"+                               , "Option"+                               , "Ordered"+                               , "Pair"+                               , "PartialFunction"+                               , "Pid"+                               , "Predef"+                               , "PriorityQueue"+                               , "PriorityQueueProxy"+                               , "Reaction"+                               , "Ref"+                               , "Responder"+                               , "RichInt"+                               , "RichString"+                               , "Rule"+                               , "RuleTransformer"+                               , "Script"+                               , "Seq"+                               , "SerialVersionUID"+                               , "Some"+                               , "Stream"+                               , "Symbol"+                               , "TcpService"+                               , "TcpServiceWorker"+                               , "Triple"+                               , "Unit"+                               , "Value"+                               , "WorkerThread"+                               , "serializable"+                               , "transient"+                               , "volatile"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren =+                          [ Rule+                              { rMatcher = AnyChar "fF"+                              , rAttribute = FloatTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = True+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCOct+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren =+                          [ Rule+                              { rMatcher = StringDetect "ULL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LUL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LLU"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "UL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LU"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "LL"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "U"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          , Rule+                              { rMatcher = StringDetect "L"+                              , rAttribute = DecValTok+                              , rIncludeAttribute = False+                              , rDynamic = False+                              , rCaseSensitive = False+                              , rChildren = []+                              , rLookahead = False+                              , rFirstNonspace = False+                              , rColumn = Nothing+                              , rContextSwitch = []+                              }+                          ]+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "//\\s*BEGIN.*$"+                              , reCompiled = Just (compileRegex True "//\\s*BEGIN.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "//\\s*END.*$"+                              , reCompiled = Just (compileRegex True "//\\s*END.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Scala" , "String" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.(format|printf)\\b"+                              , reCompiled = Just (compileRegex True "\\.(format|printf)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Scala" , "Printf" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Scala" , "Commentar 1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Scala" , "Commentar 2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "\\b[_\\w][_\\w\\d]*(?=[\\s]*(/\\*\\s*\\d+\\s*\\*/\\s*)?[(])"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "\\b[_\\w][_\\w\\d]*(?=[\\s]*(/\\*\\s*\\d+\\s*\\*/\\s*)?[(])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[.]{1,1}"+                              , reCompiled = Just (compileRegex True "[.]{1,1}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Scala" , "Member" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar ":!%&()+,-/.*<=>?[]|~^;"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Printf"+          , Context+              { cName = "Printf"+              , cSyntax = "Scala"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Scala" , "PrintfString" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "PrintfString"+          , Context+              { cName = "PrintfString"+              , cSyntax = "Scala"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "%(\\d+\\$)?(-|#|\\+|\\ |0|,|\\()*\\d*(\\.\\d+)?[a-hosxA-CEGHSX]"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "%(\\d+\\$)?(-|#|\\+|\\ |0|,|\\()*\\d*(\\.\\d+)?[a-hosxA-CEGHSX]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "%(\\d+\\$)?(-|#|\\+|\\ |0|,|\\()*\\d*(t|T)(a|A|b|B|c|C|d|D|e|F|h|H|I|j|k|l|L|m|M|N|p|P|Q|r|R|s|S|T|y|Y|z|Z)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "%(\\d+\\$)?(-|#|\\+|\\ |0|,|\\()*\\d*(t|T)(a|A|b|B|c|C|d|D|e|F|h|H|I|j|k|l|L|m|M|N|p|P|Q|r|R|s|S|T|y|Y|z|Z)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%(%|n)"+                              , reCompiled = Just (compileRegex True "%(%|n)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Scala"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Stephane Micheloud (stephane.micheloud@epfl.ch)"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions = [ "*.scala" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Scheme.hs view
@@ -0,0 +1,1138 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Scheme (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Scheme"+  , sFilename = "scheme.xml"+  , sShortname = "Scheme"+  , sContexts =+      fromList+        [ ( "Default"+          , Context+              { cName = "Default"+              , cSyntax = "Scheme"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ";+\\s*BEGIN.*$"+                              , reCompiled = Just (compileRegex True ";+\\s*BEGIN.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ";+\\s*END.*$"+                              , reCompiled = Just (compileRegex True ";+\\s*END.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ";.*$"+                              , reCompiled = Just (compileRegex True ";.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '#' '!'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Scheme" , "MultiLineComment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&(),.;[]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "abs"+                               , "acos"+                               , "and"+                               , "angle"+                               , "append"+                               , "applymap"+                               , "asin"+                               , "assoc"+                               , "assq"+                               , "assv"+                               , "atan"+                               , "begin"+                               , "boolean?"+                               , "break"+                               , "caaaar"+                               , "caaadr"+                               , "caaar"+                               , "caadar"+                               , "caaddr"+                               , "caadr"+                               , "caar"+                               , "cadaar"+                               , "cadadr"+                               , "cadar"+                               , "caddar"+                               , "cadddr"+                               , "caddr"+                               , "cadr"+                               , "call-with-current-continuation"+                               , "call-with-input-file"+                               , "call-with-output-file"+                               , "call-with-values"+                               , "call/cc"+                               , "car"+                               , "case"+                               , "catch"+                               , "cdaaar"+                               , "cdaadr"+                               , "cdaar"+                               , "cdadar"+                               , "cdaddr"+                               , "cdadr"+                               , "cdar"+                               , "cddaar"+                               , "cddadr"+                               , "cddar"+                               , "cdddar"+                               , "cddddr"+                               , "cdddr"+                               , "cddr"+                               , "cdr"+                               , "ceiling"+                               , "char->integer"+                               , "char-alphabetic?"+                               , "char-ci<=?"+                               , "char-ci=?"+                               , "char-ci>=?"+                               , "char-ci>?"+                               , "char-downcase"+                               , "char-lower-case?"+                               , "char-numeric?"+                               , "char-ready?"+                               , "char-upcase"+                               , "char-upper-case?"+                               , "char-whitespace?"+                               , "char<=?"+                               , "char<?c"+                               , "char=?"+                               , "char>=?"+                               , "char>?"+                               , "char?"+                               , "close-input-port"+                               , "close-output-port"+                               , "complex?"+                               , "cond"+                               , "cons"+                               , "continue"+                               , "cos"+                               , "current-input-port"+                               , "current-output-port"+                               , "denominator"+                               , "display"+                               , "do"+                               , "dynamic-wind"+                               , "else"+                               , "eof-object?"+                               , "eq?"+                               , "equal?"+                               , "eqv?"+                               , "eval"+                               , "even?"+                               , "exact->inexact"+                               , "exact?"+                               , "exp"+                               , "expt"+                               , "floor"+                               , "for-each"+                               , "force"+                               , "gcd"+                               , "har-ci<?"+                               , "if"+                               , "imag-part"+                               , "inexact->exact"+                               , "inexact?"+                               , "input-port?"+                               , "integer->char"+                               , "integer?"+                               , "interaction-environment"+                               , "lambda"+                               , "lcm"+                               , "length"+                               , "let"+                               , "let*"+                               , "let-syntax"+                               , "letrec"+                               , "letrec-syntax"+                               , "list"+                               , "list->string"+                               , "list-ref"+                               , "list-tail"+                               , "list?"+                               , "load"+                               , "log"+                               , "magnitude"+                               , "make-polar"+                               , "make-rectangular"+                               , "make-string"+                               , "make-vector"+                               , "max"+                               , "member"+                               , "memq"+                               , "memv"+                               , "min"+                               , "modulo"+                               , "negative?"+                               , "newline"+                               , "not"+                               , "null-environment"+                               , "null?"+                               , "number->string"+                               , "number?"+                               , "numerator"+                               , "odd?"+                               , "open-input-file"+                               , "open-output-file"+                               , "or"+                               , "output-port?"+                               , "pair?"+                               , "peek-char"+                               , "port?"+                               , "positive?"+                               , "procedure?"+                               , "quotient"+                               , "rational?"+                               , "rationalize"+                               , "read"+                               , "read-char"+                               , "real-part"+                               , "real?"+                               , "remainder"+                               , "reverse"+                               , "round"+                               , "scheme-report-environment"+                               , "set-car!"+                               , "set-cdr!"+                               , "sin"+                               , "sqrt"+                               , "string"+                               , "string->list"+                               , "string->number"+                               , "string->symbol"+                               , "string-append"+                               , "string-ci<=?"+                               , "string-ci<?"+                               , "string-ci=?"+                               , "string-ci>=?"+                               , "string-ci>?"+                               , "string-copy"+                               , "string-fill!"+                               , "string-length"+                               , "string-ref"+                               , "string-set!"+                               , "string<=?"+                               , "string<?"+                               , "string=?"+                               , "string>=?"+                               , "string>?"+                               , "string?"+                               , "substring"+                               , "symbol->string"+                               , "symbol?"+                               , "syntax-rules"+                               , "tan"+                               , "transcript-off"+                               , "transcript-on"+                               , "truncate"+                               , "values"+                               , "vector"+                               , "vector->listlist->vector"+                               , "vector-fill!"+                               , "vector-length"+                               , "vector-ref"+                               , "vector-set!"+                               , "vector?"+                               , "while"+                               , "with-input-from-file"+                               , "with-output-to-file"+                               , "write"+                               , "write-char"+                               , "zero?"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&(),.;[]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "*)"+                               , "*,*"+                               , "+"+                               , "-"+                               , "/"+                               , "<"+                               , "<="+                               , "="+                               , "=>"+                               , ">"+                               , ">="+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&(),.;[]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "define"+                               , "define*"+                               , "define*-public"+                               , "define-accessor"+                               , "define-class"+                               , "define-generic"+                               , "define-macro"+                               , "define-method"+                               , "define-module"+                               , "define-private"+                               , "define-public"+                               , "define-reader-ctor"+                               , "define-syntax"+                               , "define-syntax-macro"+                               , "defined?"+                               , "defmacro"+                               , "defmacro*"+                               , "defmacro*-public"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Scheme" , "function_decl" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&(),.;[]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "#\\ack"+                               , "#\\backspace"+                               , "#\\bel"+                               , "#\\bs"+                               , "#\\can"+                               , "#\\cr"+                               , "#\\dc1"+                               , "#\\dc2"+                               , "#\\dc3"+                               , "#\\dc4"+                               , "#\\dle"+                               , "#\\em"+                               , "#\\enq"+                               , "#\\eot"+                               , "#\\esc"+                               , "#\\etb"+                               , "#\\etx"+                               , "#\\fs"+                               , "#\\gs"+                               , "#\\ht"+                               , "#\\nak"+                               , "#\\newline"+                               , "#\\nl"+                               , "#\\np"+                               , "#\\nul"+                               , "#\\null"+                               , "#\\page"+                               , "#\\return"+                               , "#\\rs"+                               , "#\\si"+                               , "#\\so"+                               , "#\\soh"+                               , "#\\sp"+                               , "#\\space"+                               , "#\\stx"+                               , "#\\sub"+                               , "#\\syn"+                               , "#\\tab"+                               , "#\\us"+                               , "#\\vt"+                               ])+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\\\."+                              , reCompiled = Just (compileRegex True "#\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Scheme" , "String" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#[bodxei]"+                              , reCompiled = Just (compileRegex True "#[bodxei]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Scheme" , "SpecialNumber" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#[tf]"+                              , reCompiled = Just (compileRegex True "#[tf]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Scheme" , "Level1" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Level0"+          , Context+              { cName = "Level0"+              , cSyntax = "Scheme"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Scheme" , "Level1" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Scheme" , "Default" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Level1"+          , Context+              { cName = "Level1"+              , cSyntax = "Scheme"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Scheme" , "Level2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Scheme" , "Default" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Level2"+          , Context+              { cName = "Level2"+              , cSyntax = "Scheme"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Scheme" , "Level3" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Scheme" , "Default" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Level3"+          , Context+              { cName = "Level3"+              , cSyntax = "Scheme"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Scheme" , "Level4" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Scheme" , "Default" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Level4"+          , Context+              { cName = "Level4"+              , cSyntax = "Scheme"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Scheme" , "Level5" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Scheme" , "Default" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Level5"+          , Context+              { cName = "Level5"+              , cSyntax = "Scheme"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Scheme" , "Level6" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Scheme" , "Default" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Level6"+          , Context+              { cName = "Level6"+              , cSyntax = "Scheme"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Scheme" , "Level1" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Scheme" , "Default" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MultiLineComment"+          , Context+              { cName = "MultiLineComment"+              , cSyntax = "Scheme"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "!#\\s*$"+                              , reCompiled = Just (compileRegex True "!#\\s*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SpecialNumber"+          , Context+              { cName = "SpecialNumber"+              , cSyntax = "Scheme"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\d*(\\.\\d+)?"+                              , reCompiled = Just (compileRegex True "\\d*(\\.\\d+)?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Scheme"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n %&(),.;[]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "#\\ack"+                               , "#\\backspace"+                               , "#\\bel"+                               , "#\\bs"+                               , "#\\can"+                               , "#\\cr"+                               , "#\\dc1"+                               , "#\\dc2"+                               , "#\\dc3"+                               , "#\\dc4"+                               , "#\\dle"+                               , "#\\em"+                               , "#\\enq"+                               , "#\\eot"+                               , "#\\esc"+                               , "#\\etb"+                               , "#\\etx"+                               , "#\\fs"+                               , "#\\gs"+                               , "#\\ht"+                               , "#\\nak"+                               , "#\\newline"+                               , "#\\nl"+                               , "#\\np"+                               , "#\\nul"+                               , "#\\null"+                               , "#\\page"+                               , "#\\return"+                               , "#\\rs"+                               , "#\\si"+                               , "#\\so"+                               , "#\\soh"+                               , "#\\sp"+                               , "#\\space"+                               , "#\\stx"+                               , "#\\sub"+                               , "#\\syn"+                               , "#\\tab"+                               , "#\\us"+                               , "#\\vt"+                               ])+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\\\."+                              , reCompiled = Just (compileRegex True "#\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '"'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "function_decl"+          , Context+              { cName = "function_decl"+              , cSyntax = "Scheme"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*[A-Za-z0-9-+\\<\\>//\\*]*\\s*"+                              , reCompiled =+                                  Just (compileRegex True "\\s*[A-Za-z0-9-+\\<\\>//\\*]*\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Dominik Haumann (dhdev@gmx.de)"+  , sVersion = "3"+  , sLicense = "LGPLv2+"+  , sExtensions = [ "*.scm" , "*.ss" , "*.scheme" , "*.guile" ]+  , sStartingContext = "Level0"+  }
+ src/Skylighting/Syntax/Sci.hs view
@@ -0,0 +1,1343 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Sci (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "scilab"+  , sFilename = "sci.xml"+  , sShortname = "Sci"+  , sContexts =+      fromList+        [ ( "main"+          , Context+              { cName = "main"+              , cSyntax = "scilab"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "do"+                               , "else"+                               , "elseif"+                               , "end"+                               , "for"+                               , "if"+                               , "select"+                               , "then"+                               , "while"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "abort" , "break" , "pause" , "quit" , "resume" , "return" ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "endfunction" , "function" ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet True [ "error" , "warning" ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "$"+                               , "%F"+                               , "%T"+                               , "%e"+                               , "%eps"+                               , "%f"+                               , "%i"+                               , "%inf"+                               , "%io"+                               , "%nan"+                               , "%pi"+                               , "%s"+                               , "%t"+                               , "%z"+                               , "MSDOS"+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "%asn"+                               , "%helps"+                               , "%k"+                               , "%sn"+                               , "ABSBLK_f"+                               , "AFFICH_f"+                               , "ANDLOG_f"+                               , "ANIMXY_f"+                               , "AdCommunications"+                               , "BIGSOM_f"+                               , "CLINDUMMY_f"+                               , "CLKINV_f"+                               , "CLKIN_f"+                               , "CLKOUTV_f"+                               , "CLKOUT_f"+                               , "CLKSOMV_f"+                               , "CLKSOM_f"+                               , "CLKSPLIT_f"+                               , "CLOCK_f"+                               , "CLR_f"+                               , "CLSS_f"+                               , "CONST_f"+                               , "COSBLK_f"+                               , "CURV_f"+                               , "Communications"+                               , "CreateLink"+                               , "DELAYV_f"+                               , "DELAY_f"+                               , "DEMUX_f"+                               , "DLRADAPT_f"+                               , "DLR_f"+                               , "DLSS_f"+                               , "DestroyLink"+                               , "EVENTSCOPE_f"+                               , "EVTDLY_f"+                               , "EVTGEN_f"+                               , "EXPBLK_f"+                               , "Example"+                               , "ExecAppli"+                               , "ExecScilab"+                               , "ExeclScilab"+                               , "GAINBLK_f"+                               , "GAIN_f"+                               , "GENERAL_f"+                               , "GENERIC_f"+                               , "GENSIN_f"+                               , "GENSQR_f"+                               , "G_make"+                               , "GetMsg"+                               , "Graphics"+                               , "HALT_f"+                               , "IFTHEL_f"+                               , "INTEGRAL_f"+                               , "INTRP2BLK_f"+                               , "INTRPLBLK_f"+                               , "INVBLK_f"+                               , "IN_f"+                               , "LOGBLK_f"+                               , "LOOKUP_f"+                               , "MAX_f"+                               , "MCLOCK_f"+                               , "MFCLCK_f"+                               , "MIN_f"+                               , "MUX_f"+                               , "Matplot"+                               , "Matplot1"+                               , "NEGTOPOS_f"+                               , "OUT_f"+                               , "POSTONEG_f"+                               , "POWBLK_f"+                               , "PROD_f"+                               , "QUANT_f"+                               , "RAND_f"+                               , "READC_f"+                               , "REGISTER_f"+                               , "RELAY_f"+                               , "RFILE_f"+                               , "SAMPLEHOLD_f"+                               , "SAT_f"+                               , "SAWTOOTH_f"+                               , "SCOPE_f"+                               , "SCOPXY_f"+                               , "SELECT_f"+                               , "SINBLK_f"+                               , "SOM_f"+                               , "SPLIT_f"+                               , "STOP_f"+                               , "SUPER_f"+                               , "ScilabEval"+                               , "SendMsg"+                               , "Sfgrayplot"+                               , "Sgrayplot"+                               , "TANBLK_f"+                               , "TCLSS_f"+                               , "TEXT_f"+                               , "TIME_f"+                               , "TK_EvalFile"+                               , "TK_EvalStr"+                               , "TK_GetVar"+                               , "TK_SetVar"+                               , "TRASH_f"+                               , "WFILE_f"+                               , "WRITEC_f"+                               , "WaitMsg"+                               , "ZCROSS_f"+                               , "abcd"+                               , "abinv"+                               , "abs"+                               , "acos"+                               , "acosh"+                               , "acoshm"+                               , "acosm"+                               , "add_edge"+                               , "add_node"+                               , "addcolor"+                               , "addf"+                               , "addinter"+                               , "addmenu"+                               , "adj2sp"+                               , "adj_lists"+                               , "aff2ab"+                               , "alufunctions"+                               , "amell"+                               , "analpf"+                               , "analyze"+                               , "and"+                               , "ans"+                               , "apropos"+                               , "arc_graph"+                               , "arc_number"+                               , "argn"+                               , "arhnk"+                               , "arl2"+                               , "arma"+                               , "arma2p"+                               , "armac"+                               , "armax"+                               , "armax1"+                               , "arsimul"+                               , "artest"+                               , "articul"+                               , "ascii"+                               , "asin"+                               , "asinh"+                               , "asinhm"+                               , "asinm"+                               , "atan"+                               , "atanh"+                               , "atanhm"+                               , "atanm"+                               , "augment"+                               , "auread"+                               , "auwrite"+                               , "backslash"+                               , "balanc"+                               , "balreal"+                               , "bandwr"+                               , "bdiag"+                               , "besseli"+                               , "besselj"+                               , "besselk"+                               , "bessely"+                               , "best_match"+                               , "bezout"+                               , "bifish"+                               , "bilin"+                               , "binomial"+                               , "black"+                               , "bloc2exp"+                               , "bloc2ss"+                               , "bode"+                               , "bool2s"+                               , "boolean"+                               , "boucle"+                               , "bstap"+                               , "buttmag"+                               , "bvode"+                               , "c_link"+                               , "cainv"+                               , "calerf"+                               , "calfrq"+                               , "call"+                               , "canon"+                               , "casc"+                               , "ccontrg"+                               , "cdfbet"+                               , "cdfbin"+                               , "cdfchi"+                               , "cdfchn"+                               , "cdff"+                               , "cdffnc"+                               , "cdfgam"+                               , "cdfnbn"+                               , "cdfnor"+                               , "cdfpoi"+                               , "cdft"+                               , "ceil"+                               , "cepstrum"+                               , "chain_struct"+                               , "chaintest"+                               , "champ"+                               , "champ1"+                               , "chart"+                               , "chdir"+                               , "cheb1mag"+                               , "cheb2mag"+                               , "check_graph"+                               , "chepol"+                               , "chfact"+                               , "chol"+                               , "chsolve"+                               , "circuit"+                               , "classmarkov"+                               , "clean"+                               , "clear"+                               , "clearfun"+                               , "clearglobal"+                               , "close"+                               , "cls2dls"+                               , "cmb_lin"+                               , "cmndred"+                               , "code2str"+                               , "coeff"+                               , "coff"+                               , "coffg"+                               , "colcomp"+                               , "colcompr"+                               , "colinout"+                               , "colnew"+                               , "colon"+                               , "colormap"+                               , "colregul"+                               , "comp"+                               , "companion"+                               , "con_nodes"+                               , "cond"+                               , "conj"+                               , "connex"+                               , "cont_frm"+                               , "cont_mat"+                               , "contour"+                               , "contour2d"+                               , "contour2di"+                               , "contourf"+                               , "contr"+                               , "contract_edge"+                               , "contrss"+                               , "convex_hull"+                               , "convol"+                               , "convstr"+                               , "copfac"+                               , "corr"+                               , "cos"+                               , "cosh"+                               , "coshm"+                               , "cosm"+                               , "cotg"+                               , "coth"+                               , "cothm"+                               , "csim"+                               , "cspect"+                               , "ctr_gram"+                               , "cumprod"+                               , "cumsum"+                               , "curblock"+                               , "cycle_basis"+                               , "czt"+                               , "dasrt"+                               , "dassl"+                               , "datafit"+                               , "date"+                               , "dbphi"+                               , "dcf"+                               , "ddp"+                               , "debug"+                               , "dec2hex"+                               , "deff"+                               , "degree"+                               , "delbpt"+                               , "delete_arcs"+                               , "delete_nodes"+                               , "delip"+                               , "delmenu"+                               , "demos"+                               , "denom"+                               , "derivat"+                               , "derivative-"+                               , "des2ss"+                               , "des2tf"+                               , "det"+                               , "determ"+                               , "detr"+                               , "dft"+                               , "dhnorm"+                               , "diag"+                               , "diary"+                               , "diophant"+                               , "disp"+                               , "dispbpt"+                               , "dispfile"+                               , "dlgamma"+                               , "dot"+                               , "double"+                               , "dragrect"+                               , "drawaxis"+                               , "driver"+                               , "dscr"+                               , "dsimul"+                               , "dt_ility"+                               , "dtsi"+                               , "edge_number"+                               , "edit"+                               , "edit_curv"+                               , "eigenmarkov"+                               , "ell1mag"+                               , "empty"+                               , "emptystr"+                               , "eqfir"+                               , "eqiir"+                               , "equal"+                               , "equil"+                               , "equil1"+                               , "ereduc"+                               , "erf"+                               , "erfc"+                               , "erfcx"+                               , "errbar"+                               , "errcatch"+                               , "errclear"+                               , "error"+                               , "eval"+                               , "eval3d"+                               , "eval3dp"+                               , "evans"+                               , "evstr"+                               , "excel2sci"+                               , "exec"+                               , "execstr"+                               , "exists"+                               , "exit"+                               , "exp"+                               , "expm"+                               , "external"+                               , "extraction"+                               , "eye"+                               , "fac3d"+                               , "factors"+                               , "faurre"+                               , "fchamp"+                               , "fcontour"+                               , "fcontour2d"+                               , "fec"+                               , "feedback"+                               , "feval"+                               , "ffilt"+                               , "fft"+                               , "fgrayplot"+                               , "figure"+                               , "file"+                               , "fileinfo"+                               , "filter"+                               , "find"+                               , "find_freq"+                               , "find_path"+                               , "findm"+                               , "findobj"+                               , "fit_dat"+                               , "fix"+                               , "floor"+                               , "flts"+                               , "format"+                               , "formatman"+                               , "fort"+                               , "fourplan"+                               , "fplot2d"+                               , "fplot3d"+                               , "fplot3d1"+                               , "fprintf"+                               , "fprintfMat"+                               , "frep2tf"+                               , "freq"+                               , "freson"+                               , "frexp"+                               , "frfit"+                               , "frmag"+                               , "fscanf"+                               , "fscanfMat"+                               , "fsfirlin"+                               , "fsolve"+                               , "fspecg"+                               , "fstabst"+                               , "fstair"+                               , "full"+                               , "fullrf"+                               , "fullrfk"+                               , "fun2string"+                               , "funcprot"+                               , "funptr"+                               , "fusee"+                               , "g_margin"+                               , "gainplot"+                               , "gamitg"+                               , "gamma"+                               , "gammaln"+                               , "gcare"+                               , "gcd"+                               , "gcf"+                               , "gen_net"+                               , "genfac3d"+                               , "genlib"+                               , "genmarkov"+                               , "geom3d"+                               , "get"+                               , "get_function_path"+                               , "getblocklabel"+                               , "getcolor"+                               , "getcwd"+                               , "getd"+                               , "getdate"+                               , "getenv"+                               , "getf"+                               , "getfield"+                               , "getfont"+                               , "getio"+                               , "getlinestyle"+                               , "getmark"+                               , "getpid"+                               , "getscicosvars"+                               , "getsymbol"+                               , "getvalue"+                               , "getversion"+                               , "gfare"+                               , "gfrancis"+                               , "girth"+                               , "givens"+                               , "glever"+                               , "glist"+                               , "global"+                               , "gpeche"+                               , "gr_menu"+                               , "graduate"+                               , "grand"+                               , "graph-list"+                               , "graph_2_mat"+                               , "graph_center"+                               , "graph_complement"+                               , "graph_diameter"+                               , "graph_power"+                               , "graph_simp"+                               , "graph_sum"+                               , "graph_union"+                               , "graycolormap"+                               , "grayplot"+                               , "graypolarplot"+                               , "grep"+                               , "group"+                               , "gschur"+                               , "gsort"+                               , "gspec"+                               , "gstacksize"+                               , "gtild"+                               , "h2norm"+                               , "h_cl"+                               , "h_inf"+                               , "h_inf_st"+                               , "h_norm"+                               , "halt"+                               , "hamilton"+                               , "hank"+                               , "hankelsv"+                               , "hat"+                               , "havewindow"+                               , "help"+                               , "hermit"+                               , "hess"+                               , "hex2dec"+                               , "hilb"+                               , "hist3d"+                               , "histplot"+                               , "horner"+                               , "host"+                               , "hotcolormap"+                               , "householder"+                               , "hrmt"+                               , "htrianr"+                               , "hypermat"+                               , "hypermatrices"+                               , "iconvert"+                               , "ieee"+                               , "iir"+                               , "iirgroup"+                               , "iirlp"+                               , "ilib_build"+                               , "ilib_compile"+                               , "ilib_for_link"+                               , "ilib_gen_Make"+                               , "ilib_gen_gateway"+                               , "ilib_gen_loader"+                               , "im_inv"+                               , "imag"+                               , "impl"+                               , "imrep2ss"+                               , "input"+                               , "insertion"+                               , "int"+                               , "int16"+                               , "int2d"+                               , "int32"+                               , "int3d"+                               , "int8"+                               , "intc"+                               , "intdec"+                               , "integrate"+                               , "interp"+                               , "interpln"+                               , "intersci"+                               , "intersect"+                               , "intg"+                               , "intl"+                               , "intppty"+                               , "intsplin"+                               , "inttrap"+                               , "inttype"+                               , "inv"+                               , "inv_coeff"+                               , "invr"+                               , "invsyslin"+                               , "is_connex"+                               , "isdef"+                               , "iserror"+                               , "isglobal"+                               , "isinf"+                               , "isnan"+                               , "isoview"+                               , "isreal"+                               , "jmat"+                               , "kalm"+                               , "karmarkar"+                               , "kernel"+                               , "keyboard"+                               , "knapsack"+                               , "kpure"+                               , "krac2"+                               , "kron"+                               , "kroneck"+                               , "lasterror"+                               , "lattn"+                               , "lattp"+                               , "lcf"+                               , "lcm"+                               , "lcmdiag"+                               , "ldiv"+                               , "ldivf"+                               , "leastsq"+                               , "left"+                               , "legends"+                               , "length"+                               , "leqr"+                               , "less"+                               , "lev"+                               , "levin"+                               , "lex_sort"+                               , "lft"+                               , "lgfft"+                               , "lib"+                               , "lin"+                               , "lin2mu"+                               , "lindquist"+                               , "line_graph"+                               , "lines"+                               , "linf"+                               , "linfn"+                               , "link"+                               , "linpro"+                               , "linsolve"+                               , "linspace"+                               , "list"+                               , "lmisolver"+                               , "lmitool"+                               , "load"+                               , "load_graph"+                               , "loadwave"+                               , "locate"+                               , "log"+                               , "log10"+                               , "log2"+                               , "logm"+                               , "logspace"+                               , "lotest"+                               , "lqe"+                               , "lqg"+                               , "lqg2stan"+                               , "lqg_ltr"+                               , "lqr"+                               , "lsslist"+                               , "lstcat"+                               , "ltitr"+                               , "lu"+                               , "ludel"+                               , "lufact"+                               , "luget"+                               , "lusolve"+                               , "lyap"+                               , "m_circle"+                               , "macglov"+                               , "macr2lst"+                               , "macro"+                               , "macrovar"+                               , "make_graph"+                               , "man"+                               , "manedit"+                               , "mapsound"+                               , "markp2ss"+                               , "mat_2_graph"+                               , "matrices"+                               , "matrix"+                               , "max"+                               , "max_cap_path"+                               , "max_clique"+                               , "max_flow"+                               , "maxi"+                               , "mclearerr"+                               , "mclose"+                               , "mean"+                               , "median"+                               , "meof"+                               , "mese"+                               , "mesh2d"+                               , "metanet"+                               , "metanet_sync"+                               , "mfft"+                               , "mfile2sci"+                               , "mfprintf"+                               , "mfscanf"+                               , "mget"+                               , "mgeti"+                               , "mgetl"+                               , "mgetstr"+                               , "milk_drop"+                               , "min"+                               , "min_lcost_cflow"+                               , "min_lcost_flow1"+                               , "min_lcost_flow2"+                               , "min_qcost_flow"+                               , "min_weight_tree"+                               , "mine"+                               , "mini"+                               , "minreal"+                               , "minss"+                               , "minus"+                               , "mlist"+                               , "mode"+                               , "modulo"+                               , "mopen"+                               , "mprintf"+                               , "mps2linpro"+                               , "mput"+                               , "mputl"+                               , "mputstr"+                               , "mrfit"+                               , "mscanf"+                               , "mseek"+                               , "msprintf"+                               , "msscanf"+                               , "mtell"+                               , "mtlb_load"+                               , "mtlb_mode"+                               , "mtlb_save"+                               , "mtlb_sparse"+                               , "mu2lin"+                               , "mulf"+                               , "names"+                               , "narsimul"+                               , "nehari"+                               , "neighbors"+                               , "netclose"+                               , "netwindow"+                               , "netwindows"+                               , "newest"+                               , "newfun"+                               , "nf3d"+                               , "nlev"+                               , "nnz"+                               , "node_number"+                               , "nodes_2_path"+                               , "nodes_degrees"+                               , "noisegen"+                               , "norm"+                               , "not"+                               , "null"+                               , "numer"+                               , "nyquist"+                               , "obs_gram"+                               , "obscont"+                               , "obscont1"+                               , "observer"+                               , "obsv_mat"+                               , "obsvss"+                               , "ode"+                               , "ode_discrete"+                               , "ode_root"+                               , "odedc"+                               , "odedi"+                               , "odeoptions"+                               , "oldload"+                               , "oldsave"+                               , "ones"+                               , "optim"+                               , "or"+                               , "orth"+                               , "overloading"+                               , "p_margin"+                               , "param3d"+                               , "param3d1"+                               , "paramfplot2d"+                               , "parents"+                               , "parrot"+                               , "part"+                               , "path_2_nodes"+                               , "pbig"+                               , "pdiv"+                               , "pen2ea"+                               , "pencan"+                               , "penlaur"+                               , "percent"+                               , "perfect_match"+                               , "pertrans"+                               , "pfss"+                               , "phasemag"+                               , "phc"+                               , "pinv"+                               , "pipe_network"+                               , "playsnd"+                               , "plot"+                               , "plot2d"+                               , "plot2d1"+                               , "plot2d2"+                               , "plot2d3"+                               , "plot2d4"+                               , "plot3d"+                               , "plot3d1"+                               , "plot3d2"+                               , "plot3d3"+                               , "plot_graph"+                               , "plotframe"+                               , "plotprofile"+                               , "plus"+                               , "plzr"+                               , "pmodulo"+                               , "pol2des"+                               , "pol2str"+                               , "pol2tex"+                               , "polar"+                               , "polarplot"+                               , "polfact"+                               , "poly"+                               , "portr3d"+                               , "portrait"+                               , "power"+                               , "ppol"+                               , "prbs_a"+                               , "predecessors"+                               , "predef"+                               , "print"+                               , "printf"+                               , "printf_conversion"+                               , "printing"+                               , "prod"+                               , "profile"+                               , "proj"+                               , "projsl"+                               , "projspec"+                               , "psmall"+                               , "pspect"+                               , "pvm"+                               , "pvm_addhosts"+                               , "pvm_bcast"+                               , "pvm_bufinfo"+                               , "pvm_config"+                               , "pvm_delhosts"+                               , "pvm_error"+                               , "pvm_exit"+                               , "pvm_get_timer"+                               , "pvm_getinst"+                               , "pvm_gsize"+                               , "pvm_halt"+                               , "pvm_joingroup"+                               , "pvm_kill"+                               , "pvm_lvgroup"+                               , "pvm_mytid"+                               , "pvm_probe"+                               , "pvm_recv"+                               , "pvm_reduce"+                               , "pvm_sci2f77"+                               , "pvm_send"+                               , "pvm_set_timer"+                               , "pvm_spawn"+                               , "pvm_spawn_independent"+                               , "pvm_start"+                               , "pvm_tidtohost"+                               , "pvmd3"+                               , "pwd"+                               , "qassign"+                               , "qr"+                               , "quapro"+                               , "quaskro"+                               , "quit"+                               , "quote"+                               , "rand"+                               , "randpencil"+                               , "range"+                               , "rank"+                               , "rat"+                               , "rational"+                               , "rcond"+                               , "rdivf"+                               , "read"+                               , "read4b"+                               , "readb"+                               , "readc_"+                               , "readmps"+                               , "real"+                               , "recur"+                               , "reglin"+                               , "remez"+                               , "remezb"+                               , "repfreq"+                               , "replot"+                               , "residu"+                               , "ric_desc"+                               , "ricc"+                               , "riccati"+                               , "rlist"+                               , "roots"+                               , "rotate"+                               , "round"+                               , "routh_t"+                               , "rowcomp"+                               , "rowcompr"+                               , "rowinout"+                               , "rowregul"+                               , "rowshuff"+                               , "rpem"+                               , "rref"+                               , "rtitr"+                               , "salesman"+                               , "save"+                               , "save_graph"+                               , "savewave"+                               , "scaling"+                               , "scanf"+                               , "scanf_conversion"+                               , "schur"+                               , "sci2exp"+                               , "sci2for"+                               , "sci2map"+                               , "sciargs"+                               , "scicos"+                               , "scicos_block"+                               , "scicos_cpr"+                               , "scicos_graphics"+                               , "scicos_link"+                               , "scicos_main"+                               , "scicos_menus"+                               , "scicos_model"+                               , "scicosim"+                               , "scifunc_block"+                               , "scilab"+                               , "scilink"+                               , "sd2sci"+                               , "secto3d"+                               , "semi"+                               , "semicolumn"+                               , "semidef"+                               , "sensi"+                               , "set"+                               , "setbpt"+                               , "setfield"+                               , "setmenu"+                               , "setscicosvars"+                               , "sfact"+                               , "sgrid"+                               , "shortest_path"+                               , "show_arcs"+                               , "show_graph"+                               , "show_nodes"+                               , "showprofile"+                               , "sign"+                               , "signm"+                               , "simp"+                               , "simp_mode"+                               , "sin"+                               , "sinc"+                               , "sincd"+                               , "sinh"+                               , "sinhm"+                               , "sinm"+                               , "size"+                               , "slash"+                               , "sm2des"+                               , "sm2ss"+                               , "smooth"+                               , "solve"+                               , "sort"+                               , "sound"+                               , "sp2adj"+                               , "spaninter"+                               , "spanplus"+                               , "spantwo"+                               , "sparse"+                               , "spchol"+                               , "spcompack"+                               , "spec"+                               , "specfact"+                               , "speye"+                               , "spget"+                               , "splin"+                               , "split_edge"+                               , "spones"+                               , "sprand"+                               , "sprintf"+                               , "spzeros"+                               , "sqroot"+                               , "sqrt"+                               , "sqrtm"+                               , "square"+                               , "squarewave"+                               , "srfaur"+                               , "srkf"+                               , "ss2des"+                               , "ss2ss"+                               , "ss2tf"+                               , "sscanf"+                               , "sskf"+                               , "ssprint"+                               , "ssrand"+                               , "st_deviation"+                               , "st_ility"+                               , "stabil"+                               , "stacksize"+                               , "standard_define"+                               , "standard_draw"+                               , "standard_input"+                               , "standard_origin"+                               , "standard_output"+                               , "star"+                               , "startup"+                               , "str2code"+                               , "strcat"+                               , "strindex"+                               , "string"+                               , "strings"+                               , "stripblanks"+                               , "strong_con_nodes"+                               , "strong_connex"+                               , "strsubst"+                               , "subf"+                               , "subgraph"+                               , "subplot"+                               , "successors"+                               , "sum"+                               , "supernode"+                               , "sva"+                               , "svd"+                               , "svplot"+                               , "sylm"+                               , "sylv"+                               , "symbols"+                               , "sysconv"+                               , "sysdiag"+                               , "sysfact-"+                               , "syslin"+                               , "syssize"+                               , "system"+                               , "systems"+                               , "systmat"+                               , "tan"+                               , "tangent"+                               , "tanh"+                               , "tanhm"+                               , "tanm"+                               , "tdinit"+                               , "testmatrix"+                               , "texprint"+                               , "tf2des"+                               , "tf2ss"+                               , "tilda"+                               , "time_id"+                               , "timer"+                               , "titlepage"+                               , "tlist"+                               , "toeplitz"+                               , "trace"+                               , "trans"+                               , "trans_closure"+                               , "translatepaths"+                               , "trfmod"+                               , "trianfml"+                               , "tril"+                               , "trisolve"+                               , "triu"+                               , "trzeros"+                               , "type"+                               , "typename"+                               , "typeof"+                               , "ui_observer"+                               , "uicontrol"+                               , "uimenu"+                               , "uint16"+                               , "uint32"+                               , "uint8"+                               , "ulink"+                               , "union"+                               , "unique"+                               , "unix"+                               , "unix_g"+                               , "unix_s"+                               , "unix_w"+                               , "unix_x"+                               , "unobs"+                               , "unsetmenu"+                               , "user"+                               , "varargin"+                               , "varargout"+                               , "varn"+                               , "warning"+                               , "wavread"+                               , "wavwrite"+                               , "wfir"+                               , "what"+                               , "where"+                               , "whereami"+                               , "whereis"+                               , "who"+                               , "whos"+                               , "wiener"+                               , "wigner"+                               , "window"+                               , "winsid"+                               , "writb"+                               , "write"+                               , "write4b"+                               , "x_choices"+                               , "x_choose"+                               , "x_dialog"+                               , "x_matrix"+                               , "x_mdialog"+                               , "x_message"+                               , "x_message_modeless"+                               , "xarc"+                               , "xarcs"+                               , "xarrows"+                               , "xaxis"+                               , "xbasc"+                               , "xbasimp"+                               , "xbasr"+                               , "xchange"+                               , "xclea"+                               , "xclear"+                               , "xclick"+                               , "xclip"+                               , "xdel"+                               , "xend"+                               , "xfarc"+                               , "xfarcs"+                               , "xfpoly"+                               , "xfpolys"+                               , "xfrect"+                               , "xget"+                               , "xgetech"+                               , "xgetfile"+                               , "xgetmouse"+                               , "xgraduate"+                               , "xgrid"+                               , "xinfo"+                               , "xinit"+                               , "xlfont"+                               , "xload"+                               , "xname"+                               , "xnumb"+                               , "xpause"+                               , "xpoly"+                               , "xpolys"+                               , "xrect"+                               , "xrects"+                               , "xrpoly"+                               , "xs2fig"+                               , "xsave"+                               , "xsegs"+                               , "xselect"+                               , "xset"+                               , "xsetech"+                               , "xsetm"+                               , "xstring"+                               , "xstringb"+                               , "xstringl"+                               , "xtape"+                               , "xtitle"+                               , "yulewalk"+                               , "zeropen"+                               , "zeros"+                               , "zgrid"+                               , "zpbutt"+                               , "zpch1"+                               , "zpch2"+                               , "zpell"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "//.*$"+                              , reCompiled = Just (compileRegex True "//.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = RangeDetect '"' '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = ""+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.sci" , "*.sce" ]+  , sStartingContext = "main"+  }
+ src/Skylighting/Syntax/Sed.hs view
@@ -0,0 +1,2293 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Sed (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex++syntax :: Syntax+syntax = Syntax+  { sName = "sed"+  , sFilename = "sed.xml"+  , sShortname = "Sed"+  , sContexts =+      fromList+        [ ( "AICCommand"+          , Context+              { cName = "AICCommand"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = LineContinue+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "LiteralText" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "Error" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "Error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "AfterCommand"+          , Context+              { cName = "AfterCommand"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "BeginningOfLine" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "AfterCommand" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "Error" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "BeginningOfLine" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "AfterFirstAddress"+          , Context+              { cName = "AfterFirstAddress"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '!'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "Command" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "sed" , "AfterFirstAddress2" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "Error" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "BeginningOfLine" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "AfterFirstAddress2"+          , Context+              { cName = "AfterFirstAddress2"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "SecondAddress" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '~'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "Step" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "sed" , "Command" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "Error" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "BeginningOfLine" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "AfterSecondAddress"+          , Context+              { cName = "AfterSecondAddress"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '!'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "Command" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "sed" , "Command" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "Error" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "Error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "BTCommand"+          , Context+              { cName = "BTCommand"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\w+"+                              , reCompiled = Just (compileRegex True "\\w+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "AfterCommand" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "sed" , "AfterCommand" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "BeginningOfLine" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "BeginningOfLine"+          , Context+              { cName = "BeginningOfLine"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(/)"+                              , reCompiled = Just (compileRegex True "(/)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "FirstAddressRegex" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(\\S)"+                              , reCompiled = Just (compileRegex True "\\\\(\\S)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "FirstAddressRegex" ) ]+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "AfterFirstAddress" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "AfterFirstAddress" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "AfterCommand" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "Label" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '!'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "Command" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "sed" , "Command" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "Error" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Command"+          , Context+              { cName = "Command"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar 's'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "SCommand" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar 'y'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "YCommand" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "dpnDNPhHgGxFvz="+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "AfterCommand" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "aic"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "AICCommand" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "bTt"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "BTCommand" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "WwrR"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "WRCommand" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "lL"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "LCommand" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "qQ"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "QCommand" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "BeginningOfLine" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "Error" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "Error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "sed"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "BeginningOfLine" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Error"+          , Context+              { cName = "Error"+              , cSyntax = "sed"+              , cRules = []+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "BeginningOfLine" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FirstAddressRegex"+          , Context+              { cName = "FirstAddressRegex"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1" , reCompiled = Nothing , reCaseSensitive = True }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "AfterFirstAddress" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "sed" , "Regex" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "Error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "LCommand"+          , Context+              { cName = "LCommand"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "AfterCommand" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "sed" , "AfterCommand" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "BeginningOfLine" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Label"+          , Context+              { cName = "Label"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\w+"+                              , reCompiled = Just (compileRegex True "\\w+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "AfterCommand" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "Error" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "Error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "LiteralText"+          , Context+              { cName = "LiteralText"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "LiteralText" ) ]+                      }+                  , Rule+                      { rMatcher = LineContinue+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "LiteralText" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\\'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "Error" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "BeginningOfLine" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "QCommand"+          , Context+              { cName = "QCommand"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "AfterCommand" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "sed" , "AfterCommand" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "BeginningOfLine" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Regex"+          , Context+              { cName = "Regex"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '('+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ')'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '+'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '?'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '|'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '{'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '}'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '['+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' ']'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '.'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '*'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '^'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '$'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' 'n'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' 't'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '0'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '1'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '2'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '3'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '4'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '5'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '6'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '7'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '8'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '9'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '*'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '.'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '^'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "Error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SCommand"+          , Context+              { cName = "SCommand"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\S)"+                              , reCompiled = Just (compileRegex True "(\\S)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "SRegex" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "Error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SFlags"+          , Context+              { cName = "SFlags"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "gpeIiMm"+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar 'w'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "WFlag" ) ]+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "sed" , "AfterCommand" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "BeginningOfLine" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SRegex"+          , Context+              { cName = "SRegex"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(%1)"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "SReplacement" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "sed" , "Regex" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "Error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "SReplacement"+          , Context+              { cName = "SReplacement"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1" , reCompiled = Nothing , reCaseSensitive = True }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "SFlags" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[0-9LlUuE\\\\&]"+                              , reCompiled = Just (compileRegex True "\\\\[0-9LlUuE\\\\&]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '&'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "Error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "SecondAddress"+          , Context+              { cName = "SecondAddress"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(/)"+                              , reCompiled = Just (compileRegex True "(/)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "SecondAddressRegex" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\(\\S)"+                              , reCompiled = Just (compileRegex True "\\\\(\\S)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "SecondAddressRegex" ) ]+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "AfterSecondAddress" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "AfterSecondAddress" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "Error" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "Error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SecondAddressRegex"+          , Context+              { cName = "SecondAddressRegex"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1" , reCompiled = Nothing , reCaseSensitive = True }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "AfterSecondAddress" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "sed" , "Regex" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "Error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "Step"+          , Context+              { cName = "Step"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "Command" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "Error" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "Error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WFlag"+          , Context+              { cName = "WFlag"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S+"+                              , reCompiled = Just (compileRegex True "\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "SFlags" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "BeginningOfLine" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "WRCommand"+          , Context+              { cName = "WRCommand"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S+"+                              , reCompiled = Just (compileRegex True "\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "AfterCommand" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "Error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "YCommand"+          , Context+              { cName = "YCommand"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\S)"+                              , reCompiled = Just (compileRegex True "(\\S)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "YSourceList" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "Error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "YDestList"+          , Context+              { cName = "YDestList"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1" , reCompiled = Nothing , reCaseSensitive = True }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "AfterCommand" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' 'n'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "Error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "YSourceList"+          , Context+              { cName = "YSourceList"+              , cSyntax = "sed"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\%1"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(%1)"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "sed" , "YDestList" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' 'n'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '\\'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Push ( "sed" , "Error" ) ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        ]+  , sAuthor = "Bart Sas (bart.sas@gmail.com)"+  , sVersion = "2"+  , sLicense = "GPL"+  , sExtensions = [ "*.sed" ]+  , sStartingContext = "BeginningOfLine"+  }
+ src/Skylighting/Syntax/Sgml.hs view
@@ -0,0 +1,229 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Sgml (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex++syntax :: Syntax+syntax = Syntax+  { sName = "SGML"+  , sFilename = "sgml.xml"+  , sShortname = "Sgml"+  , sContexts =+      fromList+        [ ( "Attribute"+          , Context+              { cName = "Attribute"+              , cSyntax = "SGML"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*=\\s*"+                              , reCompiled = Just (compileRegex True "\\s*=\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "SGML" , "Value" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "SGML"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "-->"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal Text"+          , Context+              { cName = "Normal Text"+              , cSyntax = "SGML"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "SGML" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\s*\\/?\\s*[a-zA-Z_:][a-zA-Z0-9._:-]*"+                              , reCompiled =+                                  Just (compileRegex True "<\\s*\\/?\\s*[a-zA-Z_:][a-zA-Z0-9._:-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "SGML" , "Attribute" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Value"+          , Context+              { cName = "Value"+              , cSyntax = "SGML"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "SGML" , "Value 2" ) ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Value 2"+          , Context+              { cName = "Value 2"+              , cSyntax = "SGML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = ""+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.sgml" ]+  , sStartingContext = "Normal Text"+  }
+ src/Skylighting/Syntax/Sql.hs view
@@ -0,0 +1,1369 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Sql (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "SQL"+  , sFilename = "sql.xml"+  , sShortname = "Sql"+  , sContexts =+      fromList+        [ ( "Multiline C-style comment"+          , Context+              { cName = "Multiline C-style comment"+              , cSyntax = "SQL"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "SQL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n %&(),;?[\\]{}"+                              }+                            (makeWordSet+                               False+                               [ "ACCESS"+                               , "ACCOUNT"+                               , "ADD"+                               , "ADMIN"+                               , "ADMINISTER"+                               , "ADVISE"+                               , "AFTER"+                               , "AGENT"+                               , "ALL"+                               , "ALL_ROWS"+                               , "ALLOCATE"+                               , "ALTER"+                               , "ANALYZE"+                               , "ANCILLARY"+                               , "AND"+                               , "ANY"+                               , "ARCHIVE"+                               , "ARCHIVELOG"+                               , "AS"+                               , "ASC"+                               , "ASSERTION"+                               , "ASSOCIATE"+                               , "AT"+                               , "ATTRIBUTE"+                               , "ATTRIBUTES"+                               , "AUDIT"+                               , "AUTHENTICATED"+                               , "AUTHID"+                               , "AUTHORIZATION"+                               , "AUTOALLOCATE"+                               , "AUTOEXTEND"+                               , "AUTOMATIC"+                               , "BACKUP"+                               , "BECOME"+                               , "BEFORE"+                               , "BEGIN"+                               , "BEHALF"+                               , "BETWEEN"+                               , "BINDING"+                               , "BITMAP"+                               , "BLOCK"+                               , "BLOCK_RANGE"+                               , "BODY"+                               , "BOTH"+                               , "BOUND"+                               , "BREAK"+                               , "BROADCAST"+                               , "BTITLE"+                               , "BUFFER_POOL"+                               , "BUILD"+                               , "BULK"+                               , "BY"+                               , "CACHE"+                               , "CACHE_INSTANCES"+                               , "CALL"+                               , "CANCEL"+                               , "CASCADE"+                               , "CASE"+                               , "CATEGORY"+                               , "CHAINED"+                               , "CHANGE"+                               , "CHECK"+                               , "CHECKPOINT"+                               , "CHILD"+                               , "CHOOSE"+                               , "CHUNK"+                               , "CLASS"+                               , "CLEAR"+                               , "CLONE"+                               , "CLOSE"+                               , "CLOSE_CACHED_OPEN_CURSORS"+                               , "CLUSTER"+                               , "COALESCE"+                               , "COLUMN"+                               , "COLUMN_VALUE"+                               , "COLUMNS"+                               , "COMMENT"+                               , "COMMIT"+                               , "COMMITTED"+                               , "COMPATIBILITY"+                               , "COMPILE"+                               , "COMPLETE"+                               , "COMPOSITE_LIMIT"+                               , "COMPRESS"+                               , "COMPUTE"+                               , "CONNECT"+                               , "CONNECT_TIME"+                               , "CONSIDER"+                               , "CONSISTENT"+                               , "CONSTANT"+                               , "CONSTRAINT"+                               , "CONSTRAINTS"+                               , "CONTAINER"+                               , "CONTENTS"+                               , "CONTEXT"+                               , "CONTINUE"+                               , "CONTROLFILE"+                               , "COPY"+                               , "COST"+                               , "CPU_PER_CALL"+                               , "CPU_PER_SESSION"+                               , "CREATE"+                               , "CREATE_STORED_OUTLINES"+                               , "CROSS"+                               , "CUBE"+                               , "CURRENT"+                               , "CURSOR"+                               , "CYCLE"+                               , "DANGLING"+                               , "DATA"+                               , "DATABASE"+                               , "DATAFILE"+                               , "DATAFILES"+                               , "DBA"+                               , "DDL"+                               , "DEALLOCATE"+                               , "DEBUG"+                               , "DECLARE"+                               , "DEFAULT"+                               , "DEFERRABLE"+                               , "DEFERRED"+                               , "DEFINER"+                               , "DEGREE"+                               , "DELETE"+                               , "DEMAND"+                               , "DESC"+                               , "DETERMINES"+                               , "DICTIONARY"+                               , "DIMENSION"+                               , "DIRECTORY"+                               , "DISABLE"+                               , "DISASSOCIATE"+                               , "DISCONNECT"+                               , "DISKGROUP"+                               , "DISMOUNT"+                               , "DISTINCT"+                               , "DISTRIBUTED"+                               , "DOMAIN"+                               , "DROP"+                               , "DYNAMIC"+                               , "EACH"+                               , "ELSE"+                               , "ELSIF"+                               , "EMPTY"+                               , "ENABLE"+                               , "END"+                               , "ENFORCE"+                               , "ENTRY"+                               , "ESCAPE"+                               , "ESTIMATE"+                               , "EVENTS"+                               , "EXCEPT"+                               , "EXCEPTION"+                               , "EXCEPTIONS"+                               , "EXCHANGE"+                               , "EXCLUDING"+                               , "EXCLUSIVE"+                               , "EXEC"+                               , "EXECUTE"+                               , "EXISTS"+                               , "EXPIRE"+                               , "EXPLAIN"+                               , "EXPLOSION"+                               , "EXTENDS"+                               , "EXTENT"+                               , "EXTENTS"+                               , "EXTERNALLY"+                               , "FAILED_LOGIN_ATTEMPTS"+                               , "FALSE"+                               , "FAST"+                               , "FILE"+                               , "FILTER"+                               , "FIRST_ROWS"+                               , "FLAGGER"+                               , "FLASHBACK"+                               , "FLUSH"+                               , "FOLLOWING"+                               , "FOR"+                               , "FORCE"+                               , "FOREIGN"+                               , "FREELIST"+                               , "FREELISTS"+                               , "FRESH"+                               , "FROM"+                               , "FULL"+                               , "FUNCTION"+                               , "FUNCTIONS"+                               , "GENERATED"+                               , "GLOBAL"+                               , "GLOBAL_NAME"+                               , "GLOBALLY"+                               , "GRANT"+                               , "GROUP"+                               , "GROUPS"+                               , "HASH"+                               , "HASHKEYS"+                               , "HAVING"+                               , "HEADER"+                               , "HEAP"+                               , "HIERARCHY"+                               , "HOUR"+                               , "ID"+                               , "IDENTIFIED"+                               , "IDENTIFIER"+                               , "IDGENERATORS"+                               , "IDLE_TIME"+                               , "IF"+                               , "IMMEDIATE"+                               , "IN"+                               , "INCLUDING"+                               , "INCREMENT"+                               , "INCREMENTAL"+                               , "INDEX"+                               , "INDEXED"+                               , "INDEXES"+                               , "INDEXTYPE"+                               , "INDEXTYPES"+                               , "INDICATOR"+                               , "INITIAL"+                               , "INITIALIZED"+                               , "INITIALLY"+                               , "INITRANS"+                               , "INNER"+                               , "INSERT"+                               , "INSTANCE"+                               , "INSTANCES"+                               , "INSTEAD"+                               , "INTERMEDIATE"+                               , "INTERSECT"+                               , "INTO"+                               , "INVALIDATE"+                               , "IS"+                               , "ISOLATION"+                               , "ISOLATION_LEVEL"+                               , "JAVA"+                               , "JOIN"+                               , "KEEP"+                               , "KEY"+                               , "KILL"+                               , "LABEL"+                               , "LAYER"+                               , "LEADING"+                               , "LEFT"+                               , "LESS"+                               , "LEVEL"+                               , "LIBRARY"+                               , "LIKE"+                               , "LIMIT"+                               , "LINK"+                               , "LIST"+                               , "LOCAL"+                               , "LOCATOR"+                               , "LOCK"+                               , "LOCKED"+                               , "LOGFILE"+                               , "LOGGING"+                               , "LOGICAL_READS_PER_CALL"+                               , "LOGICAL_READS_PER_SESSION"+                               , "LOGOFF"+                               , "LOGON"+                               , "LOOP"+                               , "MANAGE"+                               , "MANAGED"+                               , "MANAGEMENT"+                               , "MASTER"+                               , "MATERIALIZED"+                               , "MAXARCHLOGS"+                               , "MAXDATAFILES"+                               , "MAXEXTENTS"+                               , "MAXINSTANCES"+                               , "MAXLOGFILES"+                               , "MAXLOGHISTORY"+                               , "MAXLOGMEMBERS"+                               , "MAXSIZE"+                               , "MAXTRANS"+                               , "MAXVALUE"+                               , "MEMBER"+                               , "MERGE"+                               , "METHOD"+                               , "MINEXTENTS"+                               , "MINIMIZE"+                               , "MINIMUM"+                               , "MINUS"+                               , "MINUTE"+                               , "MINVALUE"+                               , "MODE"+                               , "MODIFY"+                               , "MONITORING"+                               , "MOUNT"+                               , "MOVE"+                               , "MOVEMENT"+                               , "MTS_DISPATCHERS"+                               , "MULTISET"+                               , "NAMED"+                               , "NATURAL"+                               , "NEEDED"+                               , "NESTED"+                               , "NESTED_TABLE_ID"+                               , "NETWORK"+                               , "NEVER"+                               , "NEW"+                               , "NEXT"+                               , "NLS_CALENDAR"+                               , "NLS_CHARACTERSET"+                               , "NLS_COMP"+                               , "NLS_CURRENCY"+                               , "NLS_DATE_FORMAT"+                               , "NLS_DATE_LANGUAGE"+                               , "NLS_ISO_CURRENCY"+                               , "NLS_LANG"+                               , "NLS_LANGUAGE"+                               , "NLS_NUMERIC_CHARACTERS"+                               , "NLS_SORT"+                               , "NLS_SPECIAL_CHARS"+                               , "NLS_TERRITORY"+                               , "NO"+                               , "NOARCHIVELOG"+                               , "NOAUDIT"+                               , "NOCACHE"+                               , "NOCOMPRESS"+                               , "NOCYCLE"+                               , "NOFORCE"+                               , "NOLOGGING"+                               , "NOMAXVALUE"+                               , "NOMINIMIZE"+                               , "NOMINVALUE"+                               , "NOMONITORING"+                               , "NONE"+                               , "NOORDER"+                               , "NOOVERRIDE"+                               , "NOPARALLEL"+                               , "NORELY"+                               , "NORESETLOGS"+                               , "NOREVERSE"+                               , "NORMAL"+                               , "NOSEGMENT"+                               , "NOSORT"+                               , "NOT"+                               , "NOTHING"+                               , "NOVALIDATE"+                               , "NOWAIT"+                               , "NULL"+                               , "NULLS"+                               , "OBJNO"+                               , "OBJNO_REUSE"+                               , "OF"+                               , "OFF"+                               , "OFFLINE"+                               , "OID"+                               , "OIDINDEX"+                               , "OLD"+                               , "ON"+                               , "ONLINE"+                               , "ONLY"+                               , "OPCODE"+                               , "OPEN"+                               , "OPERATOR"+                               , "OPTIMAL"+                               , "OPTIMIZER_GOAL"+                               , "OPTION"+                               , "OR"+                               , "ORDER"+                               , "ORGANIZATION"+                               , "OUT"+                               , "OUTER"+                               , "OUTLINE"+                               , "OVER"+                               , "OVERFLOW"+                               , "OVERLAPS"+                               , "OWN"+                               , "PACKAGE"+                               , "PACKAGES"+                               , "PARALLEL"+                               , "PARAMETERS"+                               , "PARENT"+                               , "PARTITION"+                               , "PARTITION_HASH"+                               , "PARTITION_RANGE"+                               , "PARTITIONS"+                               , "PASSWORD"+                               , "PASSWORD_GRACE_TIME"+                               , "PASSWORD_LIFE_TIME"+                               , "PASSWORD_LOCK_TIME"+                               , "PASSWORD_REUSE_MAX"+                               , "PASSWORD_REUSE_TIME"+                               , "PASSWORD_VERIFY_FUNCTION"+                               , "PCTFREE"+                               , "PCTINCREASE"+                               , "PCTTHRESHOLD"+                               , "PCTUSED"+                               , "PCTVERSION"+                               , "PERCENT"+                               , "PERMANENT"+                               , "PLAN"+                               , "PLSQL_DEBUG"+                               , "POST_TRANSACTION"+                               , "PREBUILT"+                               , "PRECEDING"+                               , "PREPARE"+                               , "PRESENT"+                               , "PRESERVE"+                               , "PREVIOUS"+                               , "PRIMARY"+                               , "PRIOR"+                               , "PRIVATE"+                               , "PRIVATE_SGA"+                               , "PRIVILEGE"+                               , "PRIVILEGES"+                               , "PROCEDURE"+                               , "PROFILE"+                               , "PUBLIC"+                               , "PURGE"+                               , "QUERY"+                               , "QUEUE"+                               , "QUOTA"+                               , "RANDOM"+                               , "RANGE"+                               , "RBA"+                               , "READ"+                               , "READS"+                               , "REBUILD"+                               , "RECORDS_PER_BLOCK"+                               , "RECOVER"+                               , "RECOVERABLE"+                               , "RECOVERY"+                               , "RECYCLE"+                               , "REDUCED"+                               , "REFERENCES"+                               , "REFERENCING"+                               , "REFRESH"+                               , "RELY"+                               , "RENAME"+                               , "REPLACE"+                               , "RESET"+                               , "RESETLOGS"+                               , "RESIZE"+                               , "RESOLVE"+                               , "RESOLVER"+                               , "RESOURCE"+                               , "RESTRICT"+                               , "RESTRICTED"+                               , "RESUME"+                               , "RETURN"+                               , "RETURNING"+                               , "REUSE"+                               , "REVERSE"+                               , "REVOKE"+                               , "REWRITE"+                               , "RIGHT"+                               , "ROLE"+                               , "ROLES"+                               , "ROLLBACK"+                               , "ROLLUP"+                               , "ROW"+                               , "ROWNUM"+                               , "ROWS"+                               , "RULE"+                               , "SAMPLE"+                               , "SAVEPOINT"+                               , "SCAN"+                               , "SCAN_INSTANCES"+                               , "SCHEMA"+                               , "SCN"+                               , "SCOPE"+                               , "SD_ALL"+                               , "SD_INHIBIT"+                               , "SD_SHOW"+                               , "SEG_BLOCK"+                               , "SEG_FILE"+                               , "SEGMENT"+                               , "SELECT"+                               , "SELECTIVITY"+                               , "SEQUENCE"+                               , "SERIALIZABLE"+                               , "SERVERERROR"+                               , "SESSION"+                               , "SESSION_CACHED_CURSORS"+                               , "SESSIONS_PER_USER"+                               , "SET"+                               , "SHARE"+                               , "SHARED"+                               , "SHARED_POOL"+                               , "SHRINK"+                               , "SHUTDOWN"+                               , "SINGLETASK"+                               , "SIZE"+                               , "SKIP"+                               , "SKIP_UNUSABLE_INDEXES"+                               , "SNAPSHOT"+                               , "SOME"+                               , "SORT"+                               , "SOURCE"+                               , "SPECIFICATION"+                               , "SPLIT"+                               , "SQL_TRACE"+                               , "STANDBY"+                               , "START"+                               , "STARTUP"+                               , "STATEMENT_ID"+                               , "STATIC"+                               , "STATISTICS"+                               , "STOP"+                               , "STORAGE"+                               , "STORE"+                               , "STRUCTURE"+                               , "SUBMULTISET"+                               , "SUBPARTITION"+                               , "SUBPARTITIONS"+                               , "SUCCESSFUL"+                               , "SUMMARY"+                               , "SUPPLEMENTAL"+                               , "SUSPEND"+                               , "SWITCH"+                               , "SYNONYM"+                               , "SYS_OP_BITVEC"+                               , "SYS_OP_ENFORCE_NOT_NULL$"+                               , "SYS_OP_NOEXPAND"+                               , "SYS_OP_NTCIMG$"+                               , "SYSDBA"+                               , "SYSOPER"+                               , "SYSTEM"+                               , "TABLE"+                               , "TABLES"+                               , "TABLESPACE"+                               , "TABLESPACE_NO"+                               , "TABNO"+                               , "TEMPFILE"+                               , "TEMPORARY"+                               , "THAN"+                               , "THE"+                               , "THEN"+                               , "THREAD"+                               , "THROUGH"+                               , "TIME_ZONE"+                               , "TIMEOUT"+                               , "TIMEZONE_HOUR"+                               , "TIMEZONE_MINUTE"+                               , "TO"+                               , "TOPLEVEL"+                               , "TRACE"+                               , "TRACING"+                               , "TRAILING"+                               , "TRANSACTION"+                               , "TRANSITIONAL"+                               , "TRIGGER"+                               , "TRIGGERS"+                               , "TRUE"+                               , "TRUNCATE"+                               , "TYPE"+                               , "TYPES"+                               , "UNARCHIVED"+                               , "UNBOUND"+                               , "UNBOUNDED"+                               , "UNDO"+                               , "UNIFORM"+                               , "UNION"+                               , "UNIQUE"+                               , "UNLIMITED"+                               , "UNLOCK"+                               , "UNRECOVERABLE"+                               , "UNTIL"+                               , "UNUSABLE"+                               , "UNUSED"+                               , "UPD_INDEXES"+                               , "UPDATABLE"+                               , "UPDATE"+                               , "UPPPER"+                               , "USAGE"+                               , "USE"+                               , "USE_STORED_OUTLINES"+                               , "USER_DEFINED"+                               , "USING"+                               , "VALIDATE"+                               , "VALIDATION"+                               , "VALUES"+                               , "VIEW"+                               , "WHEN"+                               , "WHENEVER"+                               , "WHERE"+                               , "WHILE"+                               , "WITH"+                               , "WITHOUT"+                               , "WORK"+                               , "WRITE"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n %&(),;?[\\]{}"+                              }+                            (makeWordSet+                               False+                               [ "!="+                               , "*"+                               , "**"+                               , "+"+                               , "-"+                               , ".."+                               , "/"+                               , ":="+                               , "<"+                               , "<="+                               , "<>"+                               , "="+                               , "=>"+                               , ">"+                               , ">="+                               , "^="+                               , "||"+                               , "~="+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n %&(),;?[\\]{}"+                              }+                            (makeWordSet+                               False+                               [ "ABS"+                               , "ACOS"+                               , "ADD_MONTHS"+                               , "ASCII"+                               , "ASCIISTR"+                               , "ASIN"+                               , "ATAN"+                               , "ATAN2"+                               , "AVG"+                               , "BFILENAME"+                               , "BIN_TO_NUM"+                               , "BITAND"+                               , "CARDINALITY"+                               , "CAST"+                               , "CEIL"+                               , "CHARTOROWID"+                               , "CHR"+                               , "COALESCE"+                               , "COLLECT"+                               , "COMPOSE"+                               , "CONCAT"+                               , "CONVERT"+                               , "CORR"+                               , "CORR_K"+                               , "CORR_S"+                               , "COS"+                               , "COSH"+                               , "COUNT"+                               , "COVAR_POP"+                               , "COVAR_SAMP"+                               , "CUME_DIST"+                               , "CURRENT_DATE"+                               , "CURRENT_TIMESTAMP"+                               , "CV"+                               , "DBTIMEZONE"+                               , "DECODE"+                               , "DECOMPOSE"+                               , "DENSE_RANK"+                               , "DEPTH"+                               , "DEREF"+                               , "DUMP"+                               , "EMPTY_BLOB"+                               , "EMPTY_CLOB"+                               , "EXISTSNODE"+                               , "EXP"+                               , "EXTRACT"+                               , "EXTRACTVALUE"+                               , "FIRST"+                               , "FIRST_VALUE"+                               , "FLOOR"+                               , "FROM_TZ"+                               , "GREATEST"+                               , "GROUP_ID"+                               , "GROUPING"+                               , "GROUPING_ID"+                               , "HEXTORAW"+                               , "INITCAP"+                               , "INSTR"+                               , "INSTRB"+                               , "LAG"+                               , "LAST"+                               , "LAST_DAY"+                               , "LAST_VALUE"+                               , "LEAD"+                               , "LEAST"+                               , "LENGTH"+                               , "LENGTHB"+                               , "LN"+                               , "LNNVL"+                               , "LOCALTIMESTAMP"+                               , "LOG"+                               , "LOWER"+                               , "LPAD"+                               , "LTRIM"+                               , "MAKE_REF"+                               , "MAX"+                               , "MEDIAN"+                               , "MIN"+                               , "MOD"+                               , "MONTHS_BETWEEN"+                               , "NANVL"+                               , "NCHR"+                               , "NEW_TIME"+                               , "NEXT_DAY"+                               , "NLS_CHARSET_DECL_LEN"+                               , "NLS_CHARSET_ID"+                               , "NLS_CHARSET_NAME"+                               , "NLS_INITCAP"+                               , "NLS_LOWER"+                               , "NLS_UPPER"+                               , "NLSSORT"+                               , "NTILE"+                               , "NULLIF"+                               , "NUMTODSINTERVAL"+                               , "NUMTOYMINTERVAL"+                               , "NVL"+                               , "NVL2"+                               , "ORA_HASH"+                               , "ORA_ROWSCN"+                               , "PERCENT_RANK"+                               , "PERCENTILE_CONT"+                               , "PERCENTILE_DISC"+                               , "POWER"+                               , "POWERMULTISET"+                               , "POWERMULTISET_BY_CARDINALITY"+                               , "PRESENTNNV"+                               , "PRESENTV"+                               , "RANK"+                               , "RATIO_TO_REPORT"+                               , "RAWTOHEX"+                               , "RAWTONHEX"+                               , "REF"+                               , "REFTOHEX"+                               , "REGEXP_INSTR"+                               , "REGEXP_LIKE"+                               , "REGEXP_REPLACE"+                               , "REGEXP_SUBSTR"+                               , "REGR_AVGX"+                               , "REGR_AVGY"+                               , "REGR_COUNT"+                               , "REGR_INTERCEPT"+                               , "REGR_R2"+                               , "REGR_SLOPE"+                               , "REGR_SXX"+                               , "REGR_SXY"+                               , "REGR_SYY"+                               , "REMAINDER"+                               , "ROUND"+                               , "ROW_NUMBER"+                               , "ROWIDTOCHAR"+                               , "ROWIDTONCHAR"+                               , "RPAD"+                               , "RTRIM"+                               , "SCN_TO_TIMESTAMP"+                               , "SESSIONTIMEZONE"+                               , "SIGN"+                               , "SIN"+                               , "SINH"+                               , "SOUNDEX"+                               , "SQRT"+                               , "STATS_BINOMIAL_TEST"+                               , "STATS_CROSSTAB"+                               , "STATS_F_TEST"+                               , "STATS_KS_TEST"+                               , "STATS_MODE"+                               , "STATS_MW_TEST"+                               , "STATS_ONE_WAY_ANOVA"+                               , "STATS_T_TEST_INDEP"+                               , "STATS_T_TEST_INDEPU"+                               , "STATS_T_TEST_ONE"+                               , "STATS_T_TEST_PAIRED"+                               , "STATS_WSR_TEST"+                               , "STDDEV"+                               , "STDDEV_POP"+                               , "STDDEV_SAMP"+                               , "SUBSTR"+                               , "SUBSTRB"+                               , "SUM"+                               , "SYS_CONNECT_BY_PATH"+                               , "SYS_CONTEXT"+                               , "SYS_DBURIGEN"+                               , "SYS_EXTRACT_UTC"+                               , "SYS_GUID"+                               , "SYS_TYPEID"+                               , "SYS_XMLAGG"+                               , "SYS_XMLGEN"+                               , "SYSDATE"+                               , "SYSTIMESTAMP"+                               , "TAN"+                               , "TANH"+                               , "TIMESTAMP_TO_SCN"+                               , "TO_BINARY_DOUBLE"+                               , "TO_BINARY_FLOAT"+                               , "TO_CHAR"+                               , "TO_CLOB"+                               , "TO_DATE"+                               , "TO_DSINTERVAL"+                               , "TO_LOB"+                               , "TO_MULTI_BYTE"+                               , "TO_NCHAR"+                               , "TO_NCLOB"+                               , "TO_NUMBER"+                               , "TO_SINGLE_BYTE"+                               , "TO_TIMESTAMP"+                               , "TO_TIMESTAMP_TZ"+                               , "TO_YMINTERVAL"+                               , "TRANSLATE"+                               , "TREAT"+                               , "TRIM"+                               , "TRUNC"+                               , "TZ_OFFSET"+                               , "UID"+                               , "UNISTR"+                               , "UPDATEXML"+                               , "UPPER"+                               , "USER"+                               , "USERENV"+                               , "VALUE"+                               , "VAR_POP"+                               , "VAR_SAMP"+                               , "VARIANCE"+                               , "VSIZE"+                               , "WIDTH_BUCKET"+                               , "XMLAGG"+                               , "XMLCOLATTVAL"+                               , "XMLCONCAT"+                               , "XMLELEMENT"+                               , "XMLFOREST"+                               , "XMLSEQUENCE"+                               , "XMLTRANSFORM"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n %&(),;?[\\]{}"+                              }+                            (makeWordSet+                               False+                               [ "ANYDATA"+                               , "ANYDATASET"+                               , "ANYTYPE"+                               , "ARRAY"+                               , "BFILE"+                               , "BINARY_DOUBLE"+                               , "BINARY_FLOAT"+                               , "BINARY_INTEGER"+                               , "BLOB"+                               , "BOOLEAN"+                               , "CFILE"+                               , "CHAR"+                               , "CHARACTER"+                               , "CLOB"+                               , "DATE"+                               , "DAY"+                               , "DBURITYPE"+                               , "DEC"+                               , "DECIMAL"+                               , "DOUBLE"+                               , "FLOAT"+                               , "FLOB"+                               , "HTTPURITYPE"+                               , "INT"+                               , "INTEGER"+                               , "INTERVAL"+                               , "LOB"+                               , "LONG"+                               , "MLSLABEL"+                               , "MONTH"+                               , "NATIONAL"+                               , "NCHAR"+                               , "NCLOB"+                               , "NUMBER"+                               , "NUMERIC"+                               , "NVARCHAR"+                               , "OBJECT"+                               , "PLS_INTEGER"+                               , "PRECISION"+                               , "RAW"+                               , "REAL"+                               , "RECORD"+                               , "ROWID"+                               , "SECOND"+                               , "SINGLE"+                               , "SMALLINT"+                               , "TIME"+                               , "TIMESTAMP"+                               , "URIFACTORYTYPE"+                               , "URITYPE"+                               , "UROWID"+                               , "VARCHAR"+                               , "VARCHAR2"+                               , "VARRAY"+                               , "VARYING"+                               , "XMLTYPE"+                               , "YEAR"+                               , "ZONE"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "%(?:bulk_(?:exceptions|rowcount)|found|isopen|notfound|rowcount|rowtype|type)\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "%(?:bulk_(?:exceptions|rowcount)|found|isopen|notfound|rowcount|rowtype|type)\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "SQL" , "String literal" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '-' '-'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "SQL" , "Singleline PL/SQL-style comment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "SQL" , "Multiline C-style comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "rem\\b"+                              , reCompiled = Just (compileRegex False "rem\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "SQL" , "SQL*Plus remark directive" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "SQL" , "User-defined identifier" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(:|&&?)\\w+"+                              , reCompiled = Just (compileRegex False "(:|&&?)\\w+")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/$"+                              , reCompiled = Just (compileRegex False "/$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@@?[^@ \\t\\r\\n]"+                              , reCompiled = Just (compileRegex False "@@?[^@ \\t\\r\\n]")+                              , reCaseSensitive = False+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch =+                          [ Push ( "SQL" , "SQL*Plus directive to include file" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SQL*Plus directive to include file"+          , Context+              { cName = "SQL*Plus directive to include file"+              , cSyntax = "SQL"+              , cRules = []+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SQL*Plus remark directive"+          , Context+              { cName = "SQL*Plus remark directive"+              , cSyntax = "SQL"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Singleline PL/SQL-style comment"+          , Context+              { cName = "Singleline PL/SQL-style comment"+              , cSyntax = "SQL"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String literal"+          , Context+              { cName = "String literal"+              , cSyntax = "SQL"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&&?\\w+"+                              , reCompiled = Just (compileRegex False "&&?\\w+")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\'' '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "User-defined identifier"+          , Context+              { cName = "User-defined identifier"+              , cSyntax = "SQL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Yury Lebedev (yurylebedev@mail.ru)"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions = [ "*.sql" , "*.SQL" , "*.ddl" , "*.DDL" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/SqlMysql.hs view
@@ -0,0 +1,982 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.SqlMysql (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "SQL (MySQL)"+  , sFilename = "sql-mysql.xml"+  , sShortname = "SqlMysql"+  , sContexts =+      fromList+        [ ( "MultiLineComment"+          , Context+              { cName = "MultiLineComment"+              , cSyntax = "SQL (MySQL)"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Name"+          , Context+              { cName = "Name"+              , cSyntax = "SQL (MySQL)"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "SQL (MySQL)"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "SET(?=\\s*\\()"+                              , reCompiled = Just (compileRegex False "SET(?=\\s*\\()")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bCHARACTER SET\\b"+                              , reCompiled = Just (compileRegex False "\\bCHARACTER SET\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n %&(),;?[\\]{}"+                              }+                            (makeWordSet+                               False+                               [ "ACCESS"+                               , "ADD"+                               , "ALL"+                               , "ALTER"+                               , "ANALYZE"+                               , "AND"+                               , "AS"+                               , "ASC"+                               , "AUTO_INCREMENT"+                               , "BDB"+                               , "BERKELEYDB"+                               , "BETWEEN"+                               , "BOTH"+                               , "BY"+                               , "CASCADE"+                               , "CASE"+                               , "CHANGE"+                               , "CHARSET"+                               , "COLUMN"+                               , "COLUMNS"+                               , "CONSTRAINT"+                               , "CREATE"+                               , "CROSS"+                               , "CURRENT_DATE"+                               , "CURRENT_TIME"+                               , "CURRENT_TIMESTAMP"+                               , "DATABASE"+                               , "DATABASES"+                               , "DAY_HOUR"+                               , "DAY_MINUTE"+                               , "DAY_SECOND"+                               , "DEC"+                               , "DEFAULT"+                               , "DELAYED"+                               , "DELETE"+                               , "DESC"+                               , "DESCRIBE"+                               , "DISTINCT"+                               , "DISTINCTROW"+                               , "DROP"+                               , "ELSE"+                               , "ENCLOSED"+                               , "ESCAPED"+                               , "EXISTS"+                               , "EXPLAIN"+                               , "FIELDS"+                               , "FOR"+                               , "FOREIGN"+                               , "FROM"+                               , "FULLTEXT"+                               , "FUNCTION"+                               , "GRANT"+                               , "GROUP"+                               , "HAVING"+                               , "HIGH_PRIORITY"+                               , "IF"+                               , "IGNORE"+                               , "IN"+                               , "INDEX"+                               , "INFILE"+                               , "INNER"+                               , "INNODB"+                               , "INSERT"+                               , "INTERVAL"+                               , "INTO"+                               , "IS"+                               , "JOIN"+                               , "KEY"+                               , "KEYS"+                               , "KILL"+                               , "LEADING"+                               , "LEFT"+                               , "LIKE"+                               , "LIMIT"+                               , "LINES"+                               , "LOAD"+                               , "LOCK"+                               , "LOW_PRIORITY"+                               , "MASTER_SERVER_ID"+                               , "MATCH"+                               , "MRG_MYISAM"+                               , "NATIONAL"+                               , "NATURAL"+                               , "NOT"+                               , "NULL"+                               , "NUMERIC"+                               , "ON"+                               , "OPTIMIZE"+                               , "OPTION"+                               , "OPTIONALLY"+                               , "OR"+                               , "ORDER"+                               , "OUTER"+                               , "OUTFILE"+                               , "PARTIAL"+                               , "PRECISION"+                               , "PRIMARY"+                               , "PRIVILEGES"+                               , "PROCEDURE"+                               , "PURGE"+                               , "READ"+                               , "REFERENCES"+                               , "REGEXP"+                               , "RENAME"+                               , "REPLACE"+                               , "REQUIRE"+                               , "RESTRICT"+                               , "RETURNS"+                               , "REVOKE"+                               , "RIGHT"+                               , "RLIKE"+                               , "SELECT"+                               , "SET"+                               , "SHOW"+                               , "SONAME"+                               , "SQL_BIG_RESULT"+                               , "SQL_CALC_FOUND_ROWS"+                               , "SQL_SMALL_RESULT"+                               , "SSL"+                               , "STARTING"+                               , "STRAIGHT_JOIN"+                               , "STRIPED"+                               , "TABLE"+                               , "TABLES"+                               , "TERMINATED"+                               , "THEN"+                               , "TO"+                               , "TRAILING"+                               , "TRUNCATE"+                               , "TYPE"+                               , "UNION"+                               , "UNIQUE"+                               , "UNLOCK"+                               , "UNSIGNED"+                               , "UPDATE"+                               , "USAGE"+                               , "USE"+                               , "USER_RESOURCES"+                               , "USING"+                               , "VALUES"+                               , "VARYING"+                               , "WHEN"+                               , "WHERE"+                               , "WHILE"+                               , "WITH"+                               , "WRITE"+                               , "XOR"+                               , "YEAR_MONTH"+                               , "ZEROFILL"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n %&(),;?[\\]{}"+                              }+                            (makeWordSet+                               False+                               [ "!="+                               , "*"+                               , "**"+                               , "+"+                               , "-"+                               , ".."+                               , "/"+                               , ":="+                               , "<"+                               , "<="+                               , "<>"+                               , "="+                               , "=>"+                               , ">"+                               , ">="+                               , "^="+                               , "||"+                               , "~="+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n %&(),;?[\\]{}"+                              }+                            (makeWordSet+                               False+                               [ "ABS"+                               , "ACOS"+                               , "ADDDATE"+                               , "AES_DECRYPT"+                               , "AES_ENCRYPT"+                               , "ASCII"+                               , "ASIN"+                               , "ATAN"+                               , "ATAN2"+                               , "AVG"+                               , "BENCHMARK"+                               , "BIN"+                               , "BIT_AND"+                               , "BIT_COUNT"+                               , "BIT_LENGTH"+                               , "BIT_OR"+                               , "CAST"+                               , "CEILING"+                               , "CHAR"+                               , "CHAR_LENGTH"+                               , "CHARACTER_LENGTH"+                               , "CONCAT"+                               , "CONCAT_WS"+                               , "CONNECTION_ID"+                               , "CONV"+                               , "CONVERT"+                               , "COS"+                               , "COT"+                               , "COUNT"+                               , "CURDATE"+                               , "CURRENT_DATE"+                               , "CURRENT_TIME"+                               , "CURRENT_TIMESTAMP"+                               , "CURTIME"+                               , "DATABASE"+                               , "DATE_ADD"+                               , "DATE_FORMAT"+                               , "DATE_SUB"+                               , "DAYNAME"+                               , "DAYOFMONTH"+                               , "DAYOFWEEK"+                               , "DAYOFYEAR"+                               , "DECODE"+                               , "DEGREES"+                               , "DES_DECRYPT"+                               , "DES_ENCRYPT"+                               , "ELT"+                               , "ENCODE"+                               , "ENCRYPT"+                               , "EXP"+                               , "EXPORT_SET"+                               , "EXTRACT"+                               , "FIELD"+                               , "FIND_IN_SET"+                               , "FLOOR"+                               , "FORMAT"+                               , "FOUND_ROWS"+                               , "FROM_DAYS"+                               , "FROM_UNIXTIME"+                               , "GET_LOCK"+                               , "GREATEST"+                               , "HEX"+                               , "HOUR"+                               , "INET_ATON"+                               , "INET_NTOA"+                               , "INSERT"+                               , "INSTR"+                               , "IS_FREE_LOCK"+                               , "LAST_INSERT_ID"+                               , "LCASE"+                               , "LEAST"+                               , "LEFT"+                               , "LENGTH"+                               , "LN"+                               , "LOAD_FILE"+                               , "LOCATE"+                               , "LOG"+                               , "LOG10"+                               , "LOG2"+                               , "LOWER"+                               , "LPAD"+                               , "LTRIM"+                               , "MAKE_SET"+                               , "MASTER_POS_WAIT"+                               , "MAX"+                               , "MD5"+                               , "MID"+                               , "MIN"+                               , "MINUTE"+                               , "MOD"+                               , "MONTH"+                               , "MONTHNAME"+                               , "NOW"+                               , "OCT"+                               , "OCTET_LENGTH"+                               , "ORD"+                               , "PASSWORD"+                               , "PERIOD_ADD"+                               , "PERIOD_DIFF"+                               , "PI"+                               , "POSITION"+                               , "POW"+                               , "POWER"+                               , "QUARTER"+                               , "QUOTE"+                               , "RADIANS"+                               , "RAND"+                               , "RELEASE_LOCK"+                               , "REPEAT"+                               , "REPLACE"+                               , "REVERSE"+                               , "RIGHT"+                               , "ROUND"+                               , "RPAD"+                               , "RTRIM"+                               , "SEC_TO_TIME"+                               , "SECOND"+                               , "SESSION_USER"+                               , "SHA"+                               , "SHA1"+                               , "SIGN"+                               , "SIN"+                               , "SOUNDEX"+                               , "SPACE"+                               , "SQRT"+                               , "STD"+                               , "STDDEV"+                               , "SUBDATE"+                               , "SUBSTRING"+                               , "SUBSTRING_INDEX"+                               , "SUM"+                               , "SYSDATE"+                               , "SYSTEM_USER"+                               , "TAN"+                               , "TIME_FORMAT"+                               , "TIME_TO_SEC"+                               , "TO_DAYS"+                               , "TRIM"+                               , "UCASE"+                               , "UNIX_TIMESTAMP"+                               , "UPPER"+                               , "USER"+                               , "VERSION"+                               , "WEEK"+                               , "WEEKDAY"+                               , "YEAR"+                               , "YEARWEEK"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n %&(),;?[\\]{}"+                              }+                            (makeWordSet+                               False+                               [ "BIGINT"+                               , "BINARY"+                               , "BIT"+                               , "BLOB"+                               , "BOOL"+                               , "BOOLEAN"+                               , "CHAR"+                               , "CHARACTER"+                               , "DATE"+                               , "DATETIME"+                               , "DEC"+                               , "DECIMAL"+                               , "DOUBLE"+                               , "ENUM"+                               , "FIXED"+                               , "FLOAT"+                               , "INT"+                               , "INTEGER"+                               , "LONG"+                               , "LONGBLOB"+                               , "LONGTEXT"+                               , "MEDIUMBLOB"+                               , "MEDIUMINT"+                               , "MEDIUMTEXT"+                               , "MIDDLEINT"+                               , "NUMERIC"+                               , "REAL"+                               , "SERIAL"+                               , "SMALLINT"+                               , "TEXT"+                               , "TIME"+                               , "TIMESTAMP"+                               , "TINYBLOB"+                               , "TINYINT"+                               , "TINYTEXT"+                               , "VARBINARY"+                               , "VARCHAR"+                               , "YEAR"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "%(?:bulk_(?:exceptions|rowcount)|found|isopen|notfound|rowcount|rowtype|type)\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "%(?:bulk_(?:exceptions|rowcount)|found|isopen|notfound|rowcount|rowtype|type)\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCHex+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "SQL (MySQL)" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "SQL (MySQL)" , "String2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "SQL (MySQL)" , "Name" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "SQL (MySQL)" , "SingleLineComment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '-' '-'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "SQL (MySQL)" , "SingleLineComment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "SQL (MySQL)" , "MultiLineComment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "rem\\b"+                              , reCompiled = Just (compileRegex False "rem\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "SQL (MySQL)" , "SingleLineComment" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar ":&"+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/$"+                              , reCompiled = Just (compileRegex False "/$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@@?[^@ \\t\\r\\n]"+                              , reCompiled = Just (compileRegex False "@@?[^@ \\t\\r\\n]")+                              , reCaseSensitive = False+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "SQL (MySQL)" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '.'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Preprocessor"+          , Context+              { cName = "Preprocessor"+              , cSyntax = "SQL (MySQL)"+              , cRules = []+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SingleLineComment"+          , Context+              { cName = "SingleLineComment"+              , cSyntax = "SQL (MySQL)"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "SQL (MySQL)"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '&'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String2"+          , Context+              { cName = "String2"+              , cSyntax = "SQL (MySQL)"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '&'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Shane Wright (me@shanewright.co.uk)"+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.sql" , "*.SQL" , "*.ddl" , "*.DDL" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/SqlPostgresql.hs view
@@ -0,0 +1,1455 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.SqlPostgresql (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "SQL (PostgreSQL)"+  , sFilename = "sql-postgresql.xml"+  , sShortname = "SqlPostgresql"+  , sContexts =+      fromList+        [ ( "CreateFunction"+          , Context+              { cName = "CreateFunction"+              , cSyntax = "SQL (PostgreSQL)"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$([^\\$\\n\\r]*)\\$"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "SQL (PostgreSQL)" , "FunctionBody" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "SQL (PostgreSQL)" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FunctionBody"+          , Context+              { cName = "FunctionBody"+              , cSyntax = "SQL (PostgreSQL)"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$%1\\$"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "SQL (PostgreSQL)" , "Normal" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "Identifier"+          , Context+              { cName = "Identifier"+              , cSyntax = "SQL (PostgreSQL)"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MultiLineComment"+          , Context+              { cName = "MultiLineComment"+              , cSyntax = "SQL (PostgreSQL)"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "MultiLineString"+          , Context+              { cName = "MultiLineString"+              , cSyntax = "SQL (PostgreSQL)"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$%1\\$"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "SQL (PostgreSQL)"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "create\\s+(or\\s+replace\\s+)?function"+                              , reCompiled =+                                  Just (compileRegex False "create\\s+(or\\s+replace\\s+)?function")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "SQL (PostgreSQL)" , "CreateFunction" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "do\\s+\\$([^\\$\\n\\r]*)\\$"+                              , reCompiled =+                                  Just (compileRegex False "do\\s+\\$([^\\$\\n\\r]*)\\$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "SQL (PostgreSQL)" , "FunctionBody" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n (),;[\\]{}"+                              }+                            (makeWordSet+                               False+                               [ "ABORT"+                               , "ACCESS"+                               , "ACTION"+                               , "ADD"+                               , "ADMIN"+                               , "AFTER"+                               , "AGGREGATE"+                               , "ALIAS"+                               , "ALL"+                               , "ALLOCATE"+                               , "ALTER"+                               , "ANALYSE"+                               , "ANALYZE"+                               , "ANY"+                               , "ARE"+                               , "AS"+                               , "ASC"+                               , "ASENSITIVE"+                               , "ASSERTION"+                               , "ASSIGNMENT"+                               , "ASYMMETRIC"+                               , "AT"+                               , "ATOMIC"+                               , "AUTHORIZATION"+                               , "BACKWARD"+                               , "BEFORE"+                               , "BEGIN"+                               , "BETWEEN"+                               , "BINARY"+                               , "BOTH"+                               , "BREADTH"+                               , "BY"+                               , "C"+                               , "CACHE"+                               , "CALL"+                               , "CALLED"+                               , "CARDINALITY"+                               , "CASCADE"+                               , "CASCADED"+                               , "CASE"+                               , "CAST"+                               , "CATALOG"+                               , "CATALOG_NAME"+                               , "CHAIN"+                               , "CHAR_LENGTH"+                               , "CHARACTER_LENGTH"+                               , "CHARACTER_SET_CATALOG"+                               , "CHARACTER_SET_NAME"+                               , "CHARACTER_SET_SCHEMA"+                               , "CHARACTERISTICS"+                               , "CHECK"+                               , "CHECKED"+                               , "CHECKPOINT"+                               , "CLASS"+                               , "CLASS_ORIGIN"+                               , "CLOB"+                               , "CLOSE"+                               , "CLUSTER"+                               , "COALESCE"+                               , "COBOL"+                               , "COLLATE"+                               , "COLLATION"+                               , "COLLATION_CATALOG"+                               , "COLLATION_NAME"+                               , "COLLATION_SCHEMA"+                               , "COLUMN"+                               , "COLUMN_NAME"+                               , "COMMAND_FUNCTION"+                               , "COMMAND_FUNCTION_CODE"+                               , "COMMENT"+                               , "COMMIT"+                               , "COMMITTED"+                               , "COMPLETION"+                               , "CONDITION_NUMBER"+                               , "CONNECT"+                               , "CONNECTION"+                               , "CONNECTION_NAME"+                               , "CONSTRAINT"+                               , "CONSTRAINT_CATALOG"+                               , "CONSTRAINT_NAME"+                               , "CONSTRAINT_SCHEMA"+                               , "CONSTRAINTS"+                               , "CONSTRUCTOR"+                               , "CONTAINS"+                               , "CONTINUE"+                               , "CONVERT"+                               , "COPY"+                               , "CORRESPONDING"+                               , "COUNT"+                               , "CREATE"+                               , "CREATEDB"+                               , "CREATEUSER"+                               , "CROSS"+                               , "CUBE"+                               , "CURRENT"+                               , "CURRENT_DATE"+                               , "CURRENT_PATH"+                               , "CURRENT_ROLE"+                               , "CURRENT_TIME"+                               , "CURRENT_TIMESTAMP"+                               , "CURRENT_USER"+                               , "CURSOR"+                               , "CURSOR_NAME"+                               , "CYCLE"+                               , "DATA"+                               , "DATABASE"+                               , "DATE"+                               , "DATETIME_INTERVAL_CODE"+                               , "DATETIME_INTERVAL_PRECISION"+                               , "DAY"+                               , "DEALLOCATE"+                               , "DEC"+                               , "DECIMAL"+                               , "DECLARE"+                               , "DEFAULT"+                               , "DEFERRABLE"+                               , "DEFERRED"+                               , "DEFINED"+                               , "DEFINER"+                               , "DELETE"+                               , "DELIMITERS"+                               , "DEPTH"+                               , "DEREF"+                               , "DESC"+                               , "DESCRIBE"+                               , "DESCRIPTOR"+                               , "DESTROY"+                               , "DESTRUCTOR"+                               , "DETERMINISTIC"+                               , "DIAGNOSTICS"+                               , "DICTIONARY"+                               , "DISCONNECT"+                               , "DISPATCH"+                               , "DISTINCT"+                               , "DO"+                               , "DOMAIN"+                               , "DOUBLE"+                               , "DROP"+                               , "DYNAMIC"+                               , "DYNAMIC_FUNCTION"+                               , "DYNAMIC_FUNCTION_CODE"+                               , "EACH"+                               , "ELSE"+                               , "ENCODING"+                               , "ENCRYPTED"+                               , "END"+                               , "END-EXEC"+                               , "EQUALS"+                               , "ESCAPE"+                               , "EVERY"+                               , "EXCEPT"+                               , "EXCEPTION"+                               , "EXCLUSIVE"+                               , "EXEC"+                               , "EXECUTE"+                               , "EXISTING"+                               , "EXISTS"+                               , "EXPLAIN"+                               , "EXTERNAL"+                               , "FALSE"+                               , "FETCH"+                               , "FINAL"+                               , "FIRST"+                               , "FOR"+                               , "FORCE"+                               , "FOREIGN"+                               , "FORTRAN"+                               , "FORWARD"+                               , "FOUND"+                               , "FREE"+                               , "FREEZE"+                               , "FROM"+                               , "FULL"+                               , "FUNCTION"+                               , "G"+                               , "GENERAL"+                               , "GENERATED"+                               , "GET"+                               , "GLOBAL"+                               , "GO"+                               , "GOTO"+                               , "GRANT"+                               , "GRANTED"+                               , "GROUP"+                               , "GROUPING"+                               , "HANDLER"+                               , "HAVING"+                               , "HIERARCHY"+                               , "HOLD"+                               , "HOST"+                               , "HOUR"+                               , "IDENTITY"+                               , "IGNORE"+                               , "ILIKE"+                               , "IMMEDIATE"+                               , "IMMUTABLE"+                               , "IMPLEMENTATION"+                               , "IN"+                               , "INCREMENT"+                               , "INDEX"+                               , "INDICATOR"+                               , "INFIX"+                               , "INHERITS"+                               , "INITIALIZE"+                               , "INITIALLY"+                               , "INNER"+                               , "INOUT"+                               , "INPUT"+                               , "INSENSITIVE"+                               , "INSERT"+                               , "INSTANCE"+                               , "INSTANTIABLE"+                               , "INSTEAD"+                               , "INTERSECT"+                               , "INTERVAL"+                               , "INTO"+                               , "INVOKER"+                               , "IS"+                               , "ISNULL"+                               , "ISOLATION"+                               , "ITERATE"+                               , "JOIN"+                               , "K"+                               , "KEY"+                               , "KEY_MEMBER"+                               , "KEY_TYPE"+                               , "LANCOMPILER"+                               , "LANGUAGE"+                               , "LARGE"+                               , "LAST"+                               , "LATERAL"+                               , "LEADING"+                               , "LEFT"+                               , "LENGTH"+                               , "LESS"+                               , "LEVEL"+                               , "LIKE"+                               , "LIMIT"+                               , "LISTEN"+                               , "LOAD"+                               , "LOCAL"+                               , "LOCALTIME"+                               , "LOCALTIMESTAMP"+                               , "LOCATION"+                               , "LOCATOR"+                               , "LOCK"+                               , "LOWER"+                               , "M"+                               , "MAP"+                               , "MATCH"+                               , "MAX"+                               , "MAXVALUE"+                               , "MESSAGE_LENGTH"+                               , "MESSAGE_OCTET_LENGTH"+                               , "MESSAGE_TEXT"+                               , "METHOD"+                               , "MIN"+                               , "MINUTE"+                               , "MINVALUE"+                               , "MOD"+                               , "MODE"+                               , "MODIFIES"+                               , "MODIFY"+                               , "MODULE"+                               , "MONTH"+                               , "MORE"+                               , "MOVE"+                               , "MUMPS"+                               , "NAME"+                               , "NAMES"+                               , "NATIONAL"+                               , "NATURAL"+                               , "NEW"+                               , "NEXT"+                               , "NO"+                               , "NOCREATEDB"+                               , "NOCREATEUSER"+                               , "NONE"+                               , "NOT"+                               , "NOTHING"+                               , "NOTIFY"+                               , "NOTNULL"+                               , "NULL"+                               , "NULLABLE"+                               , "NULLIF"+                               , "NUMBER"+                               , "NUMERIC"+                               , "OBJECT"+                               , "OCTET_LENGTH"+                               , "OF"+                               , "OFF"+                               , "OFFSET"+                               , "OIDS"+                               , "OLD"+                               , "ON"+                               , "ONLY"+                               , "OPEN"+                               , "OPERATION"+                               , "OPERATOR"+                               , "OPTION"+                               , "OPTIONS"+                               , "ORDER"+                               , "ORDINALITY"+                               , "OUT"+                               , "OUTER"+                               , "OUTPUT"+                               , "OVERLAPS"+                               , "OVERLAY"+                               , "OVERRIDING"+                               , "OWNER"+                               , "PAD"+                               , "PARAMETER"+                               , "PARAMETER_MODE"+                               , "PARAMETER_NAME"+                               , "PARAMETER_ORDINAL_POSITION"+                               , "PARAMETER_SPECIFIC_CATALOG"+                               , "PARAMETER_SPECIFIC_NAME"+                               , "PARAMETER_SPECIFIC_SCHEMA"+                               , "PARAMETERS"+                               , "PARTIAL"+                               , "PASCAL"+                               , "PASSWORD"+                               , "PATH"+                               , "PENDANT"+                               , "PLI"+                               , "POSITION"+                               , "POSTFIX"+                               , "PRECISION"+                               , "PREFIX"+                               , "PREORDER"+                               , "PREPARE"+                               , "PRESERVE"+                               , "PRIMARY"+                               , "PRIOR"+                               , "PRIVILEGES"+                               , "PROCEDURAL"+                               , "PROCEDURE"+                               , "PUBLIC"+                               , "READ"+                               , "READS"+                               , "REAL"+                               , "RECURSIVE"+                               , "REF"+                               , "REFERENCES"+                               , "REFERENCING"+                               , "REINDEX"+                               , "RELATIVE"+                               , "RENAME"+                               , "REPEATABLE"+                               , "REPLACE"+                               , "RESET"+                               , "RESTRICT"+                               , "RESULT"+                               , "RETURN"+                               , "RETURNED_LENGTH"+                               , "RETURNED_OCTET_LENGTH"+                               , "RETURNED_SQLSTATE"+                               , "RETURNS"+                               , "REVOKE"+                               , "RIGHT"+                               , "ROLE"+                               , "ROLLBACK"+                               , "ROLLUP"+                               , "ROUTINE"+                               , "ROUTINE_CATALOG"+                               , "ROUTINE_NAME"+                               , "ROUTINE_SCHEMA"+                               , "ROW"+                               , "ROW_COUNT"+                               , "ROWS"+                               , "RULE"+                               , "SAVEPOINT"+                               , "SCALE"+                               , "SCHEMA"+                               , "SCHEMA_NAME"+                               , "SCOPE"+                               , "SCROLL"+                               , "SEARCH"+                               , "SECOND"+                               , "SECTION"+                               , "SECURITY"+                               , "SELECT"+                               , "SELF"+                               , "SENSITIVE"+                               , "SEQUENCE"+                               , "SERIALIZABLE"+                               , "SERVER_NAME"+                               , "SESSION"+                               , "SESSION_USER"+                               , "SET"+                               , "SETOF"+                               , "SETS"+                               , "SHARE"+                               , "SHOW"+                               , "SIMILAR"+                               , "SIMPLE"+                               , "SIZE"+                               , "SOME"+                               , "SOURCE"+                               , "SPACE"+                               , "SPECIFIC"+                               , "SPECIFIC_NAME"+                               , "SPECIFICTYPE"+                               , "SQL"+                               , "SQLCODE"+                               , "SQLERROR"+                               , "SQLEXCEPTION"+                               , "SQLSTATE"+                               , "SQLWARNING"+                               , "STABLE"+                               , "START"+                               , "STATE"+                               , "STATEMENT"+                               , "STATIC"+                               , "STATISTICS"+                               , "STDIN"+                               , "STDOUT"+                               , "STRUCTURE"+                               , "STYLE"+                               , "SUBCLASS_ORIGIN"+                               , "SUBLIST"+                               , "SUBSTRING"+                               , "SUM"+                               , "SYMMETRIC"+                               , "SYSID"+                               , "SYSTEM"+                               , "SYSTEM_USER"+                               , "TABLE"+                               , "TABLE_NAME"+                               , "TEMP"+                               , "TEMPLATE"+                               , "TEMPORARY"+                               , "TERMINATE"+                               , "THAN"+                               , "THEN"+                               , "TIMEZONE_HOUR"+                               , "TIMEZONE_MINUTE"+                               , "TO"+                               , "TOAST"+                               , "TRAILING"+                               , "TRANSACTION"+                               , "TRANSACTION_ACTIVE"+                               , "TRANSACTIONS_COMMITTED"+                               , "TRANSACTIONS_ROLLED_BACK"+                               , "TRANSFORM"+                               , "TRANSFORMS"+                               , "TRANSLATE"+                               , "TRANSLATION"+                               , "TREAT"+                               , "TRIGGER"+                               , "TRIGGER_CATALOG"+                               , "TRIGGER_NAME"+                               , "TRIGGER_SCHEMA"+                               , "TRIM"+                               , "TRUE"+                               , "TRUNCATE"+                               , "TRUSTED"+                               , "TYPE"+                               , "UNCOMMITTED"+                               , "UNDER"+                               , "UNENCRYPTED"+                               , "UNION"+                               , "UNIQUE"+                               , "UNKNOWN"+                               , "UNLISTEN"+                               , "UNNAMED"+                               , "UNNEST"+                               , "UNTIL"+                               , "UPDATE"+                               , "UPPER"+                               , "USAGE"+                               , "USER"+                               , "USER_DEFINED_TYPE_CATALOG"+                               , "USER_DEFINED_TYPE_NAME"+                               , "USER_DEFINED_TYPE_SCHEMA"+                               , "USING"+                               , "VACUUM"+                               , "VALID"+                               , "VALUE"+                               , "VALUES"+                               , "VARIABLE"+                               , "VARYING"+                               , "VERBOSE"+                               , "VERSION"+                               , "VIEW"+                               , "VOLATILE"+                               , "WHEN"+                               , "WHENEVER"+                               , "WHERE"+                               , "WHILE"+                               , "WITH"+                               , "WITHOUT"+                               , "WORK"+                               , "WRITE"+                               , "YEAR"+                               , "ZONE"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n (),;[\\]{}"+                              }+                            (makeWordSet+                               False+                               [ "!"+                               , "!!"+                               , "!="+                               , "!~"+                               , "!~*"+                               , "#"+                               , "##"+                               , "%"+                               , "&"+                               , "&&"+                               , "&<"+                               , "&>"+                               , "*"+                               , "**"+                               , "+"+                               , "-"+                               , ".."+                               , "/"+                               , ":="+                               , "<"+                               , "<->"+                               , "<<"+                               , "<<="+                               , "<="+                               , "<>"+                               , "<^"+                               , "="+                               , "=>"+                               , ">"+                               , ">="+                               , ">>"+                               , ">>="+                               , ">^"+                               , "?#"+                               , "?-"+                               , "?-|"+                               , "?|"+                               , "?||"+                               , "@"+                               , "@-@"+                               , "@@"+                               , "^"+                               , "^="+                               , "AND"+                               , "NOT"+                               , "OR"+                               , "|"+                               , "|/"+                               , "||"+                               , "||/"+                               , "~"+                               , "~*"+                               , "~="+                               ])+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n (),;[\\]{}"+                              }+                            (makeWordSet+                               False+                               [ "ABBREV"+                               , "ABS"+                               , "ACOS"+                               , "AGE"+                               , "AREA"+                               , "ASCII"+                               , "ASIN"+                               , "ATAN"+                               , "ATAN2"+                               , "AVG"+                               , "BIT_LENGTH"+                               , "BOX"+                               , "BROADCAST"+                               , "BTRIM"+                               , "CBRT"+                               , "CEIL"+                               , "CENTER"+                               , "CHAR_LENGTH"+                               , "CHARACTER_LENGTH"+                               , "CHR"+                               , "CIRCLE"+                               , "COALESCE"+                               , "COL_DESCRIPTION"+                               , "CONVERT"+                               , "COS"+                               , "COT"+                               , "COUNT"+                               , "CURRVAL"+                               , "DATE_PART"+                               , "DATE_TRUNC"+                               , "DECODE"+                               , "DEGREES"+                               , "DIAMETER"+                               , "ENCODE"+                               , "EXP"+                               , "EXTRACT"+                               , "FLOOR"+                               , "HAS_TABLE_PRIVILEGE"+                               , "HEIGHT"+                               , "HOST"+                               , "INITCAP"+                               , "ISCLOSED"+                               , "ISFINITE"+                               , "ISOPEN"+                               , "LENGTH"+                               , "LN"+                               , "LOG"+                               , "LOWER"+                               , "LPAD"+                               , "LSEG"+                               , "LTRIM"+                               , "MASKLEN"+                               , "MAX"+                               , "MIN"+                               , "MOD"+                               , "NETMASK"+                               , "NETWORK"+                               , "NEXTVAL"+                               , "NOW"+                               , "NPOINT"+                               , "NULLIF"+                               , "OBJ_DESCRIPTION"+                               , "OCTET_LENGTH"+                               , "PATH"+                               , "PCLOSE"+                               , "PG_CLIENT_ENCODING"+                               , "PG_GET_INDEXDEF"+                               , "PG_GET_RULEDEF"+                               , "PG_GET_USERBYID"+                               , "PG_GET_VIEWDEF"+                               , "PI"+                               , "POINT"+                               , "POLYGON"+                               , "POPEN"+                               , "POSITION"+                               , "POW"+                               , "RADIANS"+                               , "RADIUS"+                               , "RANDOM"+                               , "REPEAT"+                               , "ROUND"+                               , "RPAD"+                               , "RTRIM"+                               , "SET_MASKLEN"+                               , "SETVAL"+                               , "SIGN"+                               , "SIN"+                               , "SQRT"+                               , "STDDEV"+                               , "STRPOS"+                               , "SUBSTR"+                               , "SUBSTRING"+                               , "SUM"+                               , "TAN"+                               , "TIMEOFDAY"+                               , "TIMESTAMP"+                               , "TO_ASCII"+                               , "TO_CHAR"+                               , "TO_DATE"+                               , "TO_NUMBER"+                               , "TO_TIMESTAMP"+                               , "TRANSLATE"+                               , "TRIM"+                               , "TRUNC"+                               , "UPPER"+                               , "VARIANCE"+                               , "WIDTH"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims = Data.Set.fromList "\t\n (),;[\\]{}"+                              }+                            (makeWordSet+                               False+                               [ "BIGINT"+                               , "BIGSERIAL"+                               , "BIT"+                               , "BIT VARYING"+                               , "BOOL"+                               , "BOOLEAN"+                               , "BOX"+                               , "BYTEA"+                               , "CHAR"+                               , "CHARACTER"+                               , "CHARACTER VARYING"+                               , "CIDR"+                               , "CIRCLE"+                               , "DATE"+                               , "DECIMAL"+                               , "DOUBLE PRECISION"+                               , "FLOAT8"+                               , "INET"+                               , "INT"+                               , "INT2"+                               , "INT4"+                               , "INT8"+                               , "INTEGER"+                               , "INTERVAL"+                               , "LINE"+                               , "LSEG"+                               , "LZTEXT"+                               , "MACADDR"+                               , "MONEY"+                               , "NUMERIC"+                               , "OID"+                               , "PATH"+                               , "POINT"+                               , "POLYGON"+                               , "REAL"+                               , "SERIAL"+                               , "SERIAL8"+                               , "SMALLINT"+                               , "TEXT"+                               , "TIME"+                               , "TIMESTAMP"+                               , "TIMESTAMP WITH TIMEZONE"+                               , "TIMESTAMPTZ"+                               , "TIMETZ"+                               , "VARBIT"+                               , "VARCHAR"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%bulk_exceptions\\b"+                              , reCompiled = Just (compileRegex False "%bulk_exceptions\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%bulk_rowcount\\b"+                              , reCompiled = Just (compileRegex False "%bulk_rowcount\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%found\\b"+                              , reCompiled = Just (compileRegex False "%found\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%isopen\\b"+                              , reCompiled = Just (compileRegex False "%isopen\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%notfound\\b"+                              , reCompiled = Just (compileRegex False "%notfound\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%rowcount\\b"+                              , reCompiled = Just (compileRegex False "%rowcount\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%rowtype\\b"+                              , reCompiled = Just (compileRegex False "%rowtype\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%type\\b"+                              , reCompiled = Just (compileRegex False "%type\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "SQL (PostgreSQL)" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "SQL (PostgreSQL)" , "SingleLineComment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '-' '-'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "SQL (PostgreSQL)" , "SingleLineComment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "SQL (PostgreSQL)" , "MultiLineComment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "rem\\b"+                              , reCompiled = Just (compileRegex False "rem\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch =+                          [ Push ( "SQL (PostgreSQL)" , "SingleLineComment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "SQL (PostgreSQL)" , "Identifier" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar ":&"+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/$"+                              , reCompiled = Just (compileRegex False "/$")+                              , reCaseSensitive = False+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@@?[^@ \\t\\r\\n]"+                              , reCompiled = Just (compileRegex False "@@?[^@ \\t\\r\\n]")+                              , reCaseSensitive = False+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "SQL (PostgreSQL)" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$([^\\$\\n\\r]*)\\$"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "SQL (PostgreSQL)" , "MultiLineString" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Preprocessor"+          , Context+              { cName = "Preprocessor"+              , cSyntax = "SQL (PostgreSQL)"+              , cRules = []+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SingleLineComment"+          , Context+              { cName = "SingleLineComment"+              , cSyntax = "SQL (PostgreSQL)"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "SQL (PostgreSQL)"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '&'+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Shane Wright (me@shanewright.co.uk)"+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.sql" , "*.SQL" , "*.ddl" , "*.DDL" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Tcl.hs view
@@ -0,0 +1,894 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Tcl (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Tcl/Tk"+  , sFilename = "tcl.xml"+  , sShortname = "Tcl"+  , sContexts =+      fromList+        [ ( "Base"+          , Context+              { cName = "Base"+              , cSyntax = "Tcl/Tk"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*BEGIN.*$"+                              , reCompiled = Just (compileRegex True "#\\s*BEGIN.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#\\s*END.*$"+                              , reCompiled = Just (compileRegex True "#\\s*END.*$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "AppleScript"+                               , "OptProc"+                               , "after"+                               , "append"+                               , "argc"+                               , "argv"+                               , "array"+                               , "auto_execk"+                               , "auto_execok"+                               , "auto_import"+                               , "auto_load"+                               , "auto_mkindex"+                               , "auto_mkindex_old"+                               , "auto_path"+                               , "auto_qualify"+                               , "auto_reset"+                               , "beep"+                               , "bell"+                               , "bgerror"+                               , "binary"+                               , "bind"+                               , "bindtags"+                               , "break"+                               , "button"+                               , "canvas"+                               , "case"+                               , "catch"+                               , "cd"+                               , "chan"+                               , "checkbutton"+                               , "clipboard"+                               , "clock"+                               , "close"+                               , "combobox"+                               , "concat"+                               , "console"+                               , "continue"+                               , "dde"+                               , "destroy"+                               , "dict"+                               , "else"+                               , "elseif"+                               , "encoding"+                               , "entry"+                               , "env"+                               , "eof"+                               , "error"+                               , "errorCode"+                               , "errorInfo"+                               , "eval"+                               , "event"+                               , "exec"+                               , "exit"+                               , "expr"+                               , "fblocked"+                               , "fconfigure"+                               , "fcopy"+                               , "file"+                               , "fileevent"+                               , "flush"+                               , "focus"+                               , "font"+                               , "for"+                               , "foreach"+                               , "format"+                               , "frame"+                               , "gets"+                               , "glob"+                               , "global"+                               , "grab"+                               , "grid"+                               , "history"+                               , "if"+                               , "image"+                               , "incr"+                               , "info"+                               , "interp"+                               , "join"+                               , "label"+                               , "labelframe"+                               , "lappend"+                               , "lassign"+                               , "lindex"+                               , "linsert"+                               , "list"+                               , "listbox"+                               , "llength"+                               , "load"+                               , "lower"+                               , "lrange"+                               , "lremove"+                               , "lrepeat"+                               , "lreplace"+                               , "lreverse"+                               , "lsearch"+                               , "lset"+                               , "lsort"+                               , "menu"+                               , "menubutton"+                               , "message"+                               , "namespace"+                               , "notebook"+                               , "open"+                               , "option"+                               , "pack"+                               , "package"+                               , "panedwindow"+                               , "parray"+                               , "pid"+                               , "pkg_mkIndex"+                               , "place"+                               , "proc"+                               , "progressbar"+                               , "puts"+                               , "pwd"+                               , "radiobutton"+                               , "raise"+                               , "read"+                               , "regexp"+                               , "registry"+                               , "regsub"+                               , "rename"+                               , "resource"+                               , "return"+                               , "scale"+                               , "scan"+                               , "scrollbar"+                               , "seek"+                               , "selection"+                               , "send"+                               , "separator"+                               , "set"+                               , "sizegrip"+                               , "socket"+                               , "source"+                               , "spinbox"+                               , "split"+                               , "string"+                               , "style"+                               , "subst"+                               , "switch"+                               , "tclLog"+                               , "tcl_endOfWord"+                               , "tcl_findLibrary"+                               , "tcl_library"+                               , "tcl_patchLevel"+                               , "tcl_platform"+                               , "tcl_precision"+                               , "tcl_rcFileName"+                               , "tcl_rcRsrcName"+                               , "tcl_startOfNextWord"+                               , "tcl_startOfPreviousWord"+                               , "tcl_traceCompile"+                               , "tcl_traceExec"+                               , "tcl_version"+                               , "tcl_wordBreakAfter"+                               , "tcl_wordBreakBefore"+                               , "tell"+                               , "text"+                               , "time"+                               , "tk"+                               , "tkTabToWindow"+                               , "tk_chooseColor"+                               , "tk_chooseDirectory"+                               , "tk_focusFollowMouse"+                               , "tk_focusNext"+                               , "tk_focusPrev"+                               , "tk_getOpenFile"+                               , "tk_getSaveFile"+                               , "tk_library"+                               , "tk_menuSetFocus"+                               , "tk_messageBox"+                               , "tk_optionMenu"+                               , "tk_patchLevel"+                               , "tk_popup"+                               , "tk_strictMotif"+                               , "tk_textCopy"+                               , "tk_textCut"+                               , "tk_textPaste"+                               , "tk_version"+                               , "tkwait"+                               , "toplevel"+                               , "trace"+                               , "traverseTo"+                               , "treeview"+                               , "unknown"+                               , "unload"+                               , "unset"+                               , "update"+                               , "uplevel"+                               , "upvar"+                               , "variable"+                               , "vwait"+                               , "while"+                               , "winfo"+                               , "wm"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "activate"+                               , "actual"+                               , "add"+                               , "addtag"+                               , "append"+                               , "appname"+                               , "args"+                               , "aspect"+                               , "atime"+                               , "atom"+                               , "atomname"+                               , "attributes"+                               , "bbox"+                               , "bind"+                               , "body"+                               , "broadcast"+                               , "bytelength"+                               , "cancel"+                               , "canvasx"+                               , "canvasy"+                               , "caret"+                               , "cells"+                               , "cget"+                               , "channels"+                               , "children"+                               , "class"+                               , "clear"+                               , "clicks"+                               , "client"+                               , "clone"+                               , "cmdcount"+                               , "colormapfull"+                               , "colormapwindows"+                               , "command"+                               , "commands"+                               , "compare"+                               , "complete"+                               , "configure"+                               , "containing"+                               , "convertfrom"+                               , "convertto"+                               , "coords"+                               , "copy"+                               , "create"+                               , "current"+                               , "curselection"+                               , "dchars"+                               , "debug"+                               , "default"+                               , "deiconify"+                               , "delete"+                               , "delta"+                               , "depth"+                               , "deselect"+                               , "dirname"+                               , "dlineinfo"+                               , "dtag"+                               , "dump"+                               , "edit"+                               , "entrycget"+                               , "entryconfigure"+                               , "equal"+                               , "executable"+                               , "exists"+                               , "extension"+                               , "families"+                               , "find"+                               , "first"+                               , "flash"+                               , "focus"+                               , "focusmodel"+                               , "forget"+                               , "format"+                               , "fpixels"+                               , "fraction"+                               , "frame"+                               , "functions"+                               , "generate"+                               , "geometry"+                               , "get"+                               , "gettags"+                               , "globals"+                               , "grid"+                               , "group"+                               , "handle"+                               , "height"+                               , "hide"+                               , "hostname"+                               , "iconbitmap"+                               , "iconify"+                               , "iconmask"+                               , "iconname"+                               , "iconposition"+                               , "iconwindow"+                               , "icursor"+                               , "id"+                               , "identify"+                               , "idle"+                               , "ifneeded"+                               , "image"+                               , "index"+                               , "info"+                               , "insert"+                               , "interps"+                               , "inuse"+                               , "invoke"+                               , "is"+                               , "isdirectory"+                               , "isfile"+                               , "ismapped"+                               , "itemcget"+                               , "itemconfigure"+                               , "join"+                               , "keys"+                               , "last"+                               , "length"+                               , "level"+                               , "library"+                               , "link"+                               , "loaded"+                               , "locals"+                               , "lower"+                               , "lstat"+                               , "manager"+                               , "map"+                               , "mark"+                               , "match"+                               , "maxsize"+                               , "measure"+                               , "metrics"+                               , "minsize"+                               , "mkdir"+                               , "move"+                               , "mtime"+                               , "name"+                               , "nameofexecutable"+                               , "names"+                               , "nativename"+                               , "nearest"+                               , "normalize"+                               , "number"+                               , "overrideredirect"+                               , "own"+                               , "owned"+                               , "panecget"+                               , "paneconfigure"+                               , "panes"+                               , "parent"+                               , "patchlevel"+                               , "pathname"+                               , "pathtype"+                               , "pixels"+                               , "pointerx"+                               , "pointerxy"+                               , "pointery"+                               , "positionfrom"+                               , "post"+                               , "postcascade"+                               , "postscript"+                               , "present"+                               , "procs"+                               , "protocol"+                               , "provide"+                               , "proxy"+                               , "raise"+                               , "range"+                               , "readable"+                               , "readlink"+                               , "release"+                               , "remove"+                               , "rename"+                               , "repeat"+                               , "replace"+                               , "reqheight"+                               , "require"+                               , "reqwidth"+                               , "resizable"+                               , "rgb"+                               , "rootname"+                               , "rootx"+                               , "rooty"+                               , "scale"+                               , "scaling"+                               , "scan"+                               , "screen"+                               , "screencells"+                               , "screendepth"+                               , "screenheight"+                               , "screenmmheight"+                               , "screenmmwidth"+                               , "screenvisual"+                               , "screenwidth"+                               , "script"+                               , "search"+                               , "seconds"+                               , "see"+                               , "select"+                               , "selection"+                               , "separator"+                               , "server"+                               , "set"+                               , "sharedlibextension"+                               , "show"+                               , "size"+                               , "sizefrom"+                               , "split"+                               , "stackorder"+                               , "stat"+                               , "state"+                               , "status"+                               , "system"+                               , "tag"+                               , "tail"+                               , "tclversion"+                               , "title"+                               , "tolower"+                               , "toplevel"+                               , "totitle"+                               , "toupper"+                               , "transient"+                               , "trim"+                               , "trimleft"+                               , "trimright"+                               , "type"+                               , "types"+                               , "unknown"+                               , "unpost"+                               , "useinputmethods"+                               , "validate"+                               , "values"+                               , "variable"+                               , "vars"+                               , "vcompare"+                               , "vdelete"+                               , "versions"+                               , "viewable"+                               , "vinfo"+                               , "visual"+                               , "visualid"+                               , "visualsavailable"+                               , "volumes"+                               , "vrootheight"+                               , "vrootwidth"+                               , "vrootx"+                               , "vrooty"+                               , "vsatisfies"+                               , "width"+                               , "window"+                               , "windowingsystem"+                               , "withdraw"+                               , "wordend"+                               , "wordstart"+                               , "writable"+                               , "x"+                               , "xview"+                               , "y"+                               ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s-\\w+"+                              , reCompiled = Just (compileRegex True "\\s-\\w+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\{([^\\}]|\\\\\\})+\\}"+                              , reCompiled =+                                  Just (compileRegex True "\\$\\{([^\\}]|\\\\\\})+\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$(::|\\w)+"+                              , reCompiled = Just (compileRegex True "\\$(::|\\w)+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\"{2}"+                              , reCompiled = Just (compileRegex True "\"{2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\""+                              , reCompiled = Just (compileRegex True "\"")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcl/Tk" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcl/Tk" , "New command line" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcl/Tk" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "Tcl/Tk"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "New command line"+          , Context+              { cName = "New command line"+              , cSyntax = "Tcl/Tk"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*#"+                              , reCompiled = Just (compileRegex True "\\s*#")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcl/Tk" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Tcl/Tk"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = ""+  , sVersion = "3"+  , sLicense = "BSD"+  , sExtensions = [ "*.tcl" , "*.tk" ]+  , sStartingContext = "Base"+  }
+ src/Skylighting/Syntax/Tcsh.hs view
@@ -0,0 +1,3877 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Tcsh (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Tcsh"+  , sFilename = "tcsh.xml"+  , sShortname = "Tcsh"+  , sContexts =+      fromList+        [ ( "Assign"+          , Context+              { cName = "Assign"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "AssignArray" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\w:,+_./-]+"+                              , reCompiled = Just (compileRegex True "[\\w:,+_./-]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "AssignArray"+          , Context+              { cName = "AssignArray"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "Subscript" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "Assign" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "AssignSubscr"+          , Context+              { cName = "AssignSubscr"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "Subscript" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "Assign" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "CmdSetEnv"+          , Context+              { cName = "CmdSetEnv"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[A-Za-z_][A-Za-z0-9_]*"+                              , reCompiled = Just (compileRegex True "\\b[A-Za-z_][A-Za-z0-9_]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar ' '+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "Assign" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CommentBackq"+          , Context+              { cName = "CommentBackq"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^`](?=`)"+                              , reCompiled = Just (compileRegex True "[^`](?=`)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CommentParen"+          , Context+              { cName = "CommentParen"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^)](?=\\))"+                              , reCompiled = Just (compileRegex True "[^)](?=\\))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ExprBracket"+          , Context+              { cName = "ExprBracket"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s\\](?=($|[\\s;|&]))"+                              , reCompiled = Just (compileRegex True "\\s\\](?=($|[\\s;|&]))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\](?=($|[\\s;|&]))"+                              , reCompiled = Just (compileRegex True "\\](?=($|[\\s;|&]))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "ExprSubParen" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindTests" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ExprDblBracket"+          , Context+              { cName = "ExprDblBracket"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s\\]\\](?=($|[\\s;|&]))"+                              , reCompiled = Just (compileRegex True "\\s\\]\\](?=($|[\\s;|&]))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\]\\](?=($|[\\s;|&]))"+                              , reCompiled = Just (compileRegex True "\\]\\](?=($|[\\s;|&]))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "ExprSubParen" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindTests" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ExprDblParen"+          , Context+              { cName = "ExprDblParen"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars ')' ')'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "ExprSubParen" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ExprDblParenSubst"+          , Context+              { cName = "ExprDblParenSubst"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars ')' ')'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "ExprSubParen" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ExprSubParen"+          , Context+              { cName = "ExprSubParen"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "ExprSubParen" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindAll"+          , Context+              { cName = "FindAll"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindComments" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindCommands" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindCommands"+          , Context+              { cName = "FindCommands"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '(' '('+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "ExprDblParen" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[\\[(?=($|\\s))"+                              , reCompiled = Just (compileRegex True "\\[\\[(?=($|\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Tcsh" , "ExprDblBracket" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s\\[\\[(?=($|\\s))"+                              , reCompiled = Just (compileRegex True "\\s\\[\\[(?=($|\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "ExprDblBracket" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[(?=($|\\s))"+                              , reCompiled = Just (compileRegex True "\\[(?=($|\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Tcsh" , "ExprBracket" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s\\[(?=($|\\s))"+                              , reCompiled = Just (compileRegex True "\\s\\[(?=($|\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "ExprBracket" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{(?=($|\\s))"+                              , reCompiled = Just (compileRegex True "\\{(?=($|\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "Group" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "SubShell" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bdo(?![\\w$+-])"+                              , reCompiled = Just (compileRegex True "\\bdo(?![\\w$+-])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bdone(?![\\w$+-])"+                              , reCompiled = Just (compileRegex True "\\bdone(?![\\w$+-])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\belse\\s+if(?![\\w$+-])"+                              , reCompiled = Just (compileRegex True "\\belse\\s+if(?![\\w$+-])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bif(?![\\w$+-])"+                              , reCompiled = Just (compileRegex True "\\bif(?![\\w$+-])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bendif(?![\\w$+-])"+                              , reCompiled = Just (compileRegex True "\\bendif(?![\\w$+-])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bswitch(?![\\w$+-])"+                              , reCompiled = Just (compileRegex True "\\bswitch(?![\\w$+-])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "Switch" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-[A-Za-z0-9][A-Za-z0-9_]*"+                              , reCompiled = Just (compileRegex True "-[A-Za-z0-9][A-Za-z0-9_]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "--[a-z][A-Za-z0-9_-]*"+                              , reCompiled = Just (compileRegex True "--[a-z][A-Za-z0-9_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b@\\s"+                              , reCompiled = Just (compileRegex True "\\b@\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bset\\s"+                              , reCompiled = Just (compileRegex True "\\bset\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bsetenv\\s"+                              , reCompiled = Just (compileRegex True "\\bsetenv\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "CmdSetEnv" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect ":()"+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bfunction\\b"+                              , reCompiled = Just (compileRegex True "\\bfunction\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "FunctionDef" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,/;<=>?\\`|~"+                              }+                            (makeWordSet+                               True+                               [ "."+                               , "else"+                               , "for"+                               , "function"+                               , "in"+                               , "select"+                               , "then"+                               , "until"+                               , "while"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,/;<=>?\\`|~"+                              }+                            (makeWordSet+                               True+                               [ ":"+                               , "alias"+                               , "alloc"+                               , "bg"+                               , "bindkey"+                               , "break"+                               , "builtins"+                               , "bye"+                               , "cd"+                               , "chdir"+                               , "complete"+                               , "continue"+                               , "dirs"+                               , "echo"+                               , "echotc"+                               , "eval"+                               , "exec"+                               , "exit"+                               , "fg"+                               , "filetest"+                               , "glob"+                               , "hashstat"+                               , "history"+                               , "hup"+                               , "inlib"+                               , "jobs"+                               , "kill"+                               , "limit"+                               , "log"+                               , "login"+                               , "logout"+                               , "ls-F"+                               , "migrate"+                               , "newgrp"+                               , "nice"+                               , "nohup"+                               , "notify"+                               , "onintr"+                               , "popd"+                               , "printenv"+                               , "pushd"+                               , "rehash"+                               , "repeat"+                               , "sched"+                               , "settc"+                               , "setty"+                               , "shift"+                               , "source"+                               , "stop"+                               , "suspend"+                               , "telltc"+                               , "time"+                               , "umask"+                               , "unalias"+                               , "uncomplete"+                               , "unhash"+                               , "unlimit"+                               , "ver"+                               , "wait"+                               , "watchlog"+                               , "where"+                               , "which"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,/;<=>?\\`|~"+                              }+                            (makeWordSet+                               True+                               [ "aclocal"+                               , "aconnect"+                               , "aplay"+                               , "apm"+                               , "apmsleep"+                               , "apropos"+                               , "ar"+                               , "arch"+                               , "arecord"+                               , "as"+                               , "as86"+                               , "autoconf"+                               , "autoheader"+                               , "automake"+                               , "awk"+                               , "basename"+                               , "bash"+                               , "bc"+                               , "bison"+                               , "bunzip2"+                               , "bzcat"+                               , "bzcmp"+                               , "bzdiff"+                               , "bzegrep"+                               , "bzfgrep"+                               , "bzgrep"+                               , "bzip2"+                               , "bzip2recover"+                               , "bzless"+                               , "bzmore"+                               , "c++"+                               , "cal"+                               , "cat"+                               , "cc"+                               , "cd-read"+                               , "cdda2wav"+                               , "cdparanoia"+                               , "cdrdao"+                               , "cdrecord"+                               , "chattr"+                               , "chfn"+                               , "chgrp"+                               , "chmod"+                               , "chown"+                               , "chroot"+                               , "chsh"+                               , "chvt"+                               , "clear"+                               , "cmp"+                               , "co"+                               , "col"+                               , "comm"+                               , "cp"+                               , "cpio"+                               , "cpp"+                               , "cut"+                               , "date"+                               , "dc"+                               , "dcop"+                               , "dd"+                               , "deallocvt"+                               , "df"+                               , "diff"+                               , "diff3"+                               , "dir"+                               , "dircolors"+                               , "directomatic"+                               , "dirname"+                               , "dmesg"+                               , "dnsdomainname"+                               , "domainname"+                               , "du"+                               , "dumpkeys"+                               , "echo"+                               , "ed"+                               , "egrep"+                               , "env"+                               , "expr"+                               , "false"+                               , "fbset"+                               , "fgconsole"+                               , "fgrep"+                               , "file"+                               , "find"+                               , "flex"+                               , "flex++"+                               , "fmt"+                               , "free"+                               , "ftp"+                               , "funzip"+                               , "fuser"+                               , "g++"+                               , "gawk"+                               , "gc"+                               , "gcc"+                               , "gdb"+                               , "getent"+                               , "getkeycodes"+                               , "getopt"+                               , "gettext"+                               , "gettextize"+                               , "gimp"+                               , "gimp-remote"+                               , "gimptool"+                               , "gmake"+                               , "gocr"+                               , "grep"+                               , "groff"+                               , "groups"+                               , "gs"+                               , "gunzip"+                               , "gzexe"+                               , "gzip"+                               , "head"+                               , "hexdump"+                               , "hostname"+                               , "id"+                               , "igawk"+                               , "install"+                               , "join"+                               , "kbd_mode"+                               , "kbdrate"+                               , "kdialog"+                               , "kfile"+                               , "kill"+                               , "killall"+                               , "last"+                               , "lastb"+                               , "ld"+                               , "ld86"+                               , "ldd"+                               , "less"+                               , "lex"+                               , "link"+                               , "ln"+                               , "loadkeys"+                               , "loadunimap"+                               , "locate"+                               , "lockfile"+                               , "login"+                               , "logname"+                               , "lp"+                               , "lpr"+                               , "ls"+                               , "lsattr"+                               , "lsmod"+                               , "lsmod.old"+                               , "lynx"+                               , "m4"+                               , "make"+                               , "man"+                               , "mapscrn"+                               , "mesg"+                               , "mkdir"+                               , "mkfifo"+                               , "mknod"+                               , "mktemp"+                               , "more"+                               , "mount"+                               , "msgfmt"+                               , "mv"+                               , "namei"+                               , "nano"+                               , "nasm"+                               , "nawk"+                               , "netstat"+                               , "nice"+                               , "nisdomainname"+                               , "nl"+                               , "nm"+                               , "nm86"+                               , "nmap"+                               , "nohup"+                               , "nop"+                               , "nroff"+                               , "od"+                               , "openvt"+                               , "passwd"+                               , "patch"+                               , "pcregrep"+                               , "pcretest"+                               , "perl"+                               , "perror"+                               , "pgawk"+                               , "pidof"+                               , "ping"+                               , "pr"+                               , "printf"+                               , "procmail"+                               , "prune"+                               , "ps"+                               , "ps2ascii"+                               , "ps2epsi"+                               , "ps2frag"+                               , "ps2pdf"+                               , "ps2ps"+                               , "psbook"+                               , "psmerge"+                               , "psnup"+                               , "psresize"+                               , "psselect"+                               , "pstops"+                               , "pstree"+                               , "pwd"+                               , "rbash"+                               , "rcs"+                               , "readlink"+                               , "red"+                               , "resizecons"+                               , "rev"+                               , "rm"+                               , "rmdir"+                               , "run-parts"+                               , "sash"+                               , "scp"+                               , "sed"+                               , "seq"+                               , "setfont"+                               , "setkeycodes"+                               , "setleds"+                               , "setmetamode"+                               , "setserial"+                               , "setterm"+                               , "sh"+                               , "showkey"+                               , "shred"+                               , "size"+                               , "size86"+                               , "skill"+                               , "sleep"+                               , "slogin"+                               , "snice"+                               , "sort"+                               , "sox"+                               , "split"+                               , "ssed"+                               , "ssh"+                               , "ssh-add"+                               , "ssh-agent"+                               , "ssh-keygen"+                               , "ssh-keyscan"+                               , "stat"+                               , "strings"+                               , "strip"+                               , "stty"+                               , "su"+                               , "sudo"+                               , "suidperl"+                               , "sum"+                               , "sync"+                               , "tac"+                               , "tail"+                               , "tar"+                               , "tee"+                               , "tempfile"+                               , "test"+                               , "touch"+                               , "tr"+                               , "troff"+                               , "true"+                               , "umount"+                               , "uname"+                               , "unicode_start"+                               , "unicode_stop"+                               , "uniq"+                               , "unlink"+                               , "unzip"+                               , "updatedb"+                               , "updmap"+                               , "uptime"+                               , "users"+                               , "utmpdump"+                               , "uuidgen"+                               , "vdir"+                               , "vmstat"+                               , "w"+                               , "wall"+                               , "wc"+                               , "wget"+                               , "whatis"+                               , "whereis"+                               , "which"+                               , "who"+                               , "whoami"+                               , "write"+                               , "xargs"+                               , "xhost"+                               , "xmodmap"+                               , "xset"+                               , "yacc"+                               , "yes"+                               , "ypdomainname"+                               , "zcat"+                               , "zcmp"+                               , "zdiff"+                               , "zegrep"+                               , "zfgrep"+                               , "zforce"+                               , "zgrep"+                               , "zip"+                               , "zless"+                               , "zmore"+                               , "znew"+                               , "zsh"+                               , "zsoelim"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,/;<=>?\\`|~"+                              }+                            (makeWordSet True [ "unset" , "unsetenv" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "VarName" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<?|>>?&?!?)"+                              , reCompiled = Just (compileRegex True "(<<?|>>?&?!?)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([|&])\\1?"+                              , reCompiled = Just (compileRegex True "([|&])\\1?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Za-z_:][A-Za-z0-9_:#%@-]*\\s*\\(\\)"+                              , reCompiled =+                                  Just (compileRegex True "[A-Za-z_:][A-Za-z0-9_:#%@-]*\\s*\\(\\)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindComments"+          , Context+              { cName = "FindComments"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\s;](?=#)"+                              , reCompiled = Just (compileRegex True "[\\s;](?=#)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "Comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindCommentsBackq"+          , Context+              { cName = "FindCommentsBackq"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "CommentBackq" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\s;](?=#)"+                              , reCompiled = Just (compileRegex True "[\\s;](?=#)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "CommentBackq" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindCommentsParen"+          , Context+              { cName = "FindCommentsParen"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "CommentParen" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\s;](?=#)"+                              , reCompiled = Just (compileRegex True "[\\s;](?=#)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "CommentParen" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindMost"+          , Context+              { cName = "FindMost"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindComments" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindOthers"+          , Context+              { cName = "FindOthers"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[;\"\\\\'$`{}()|&<>* ]"+                              , reCompiled =+                                  Just (compileRegex True "\\\\[;\"\\\\'$`{}()|&<>* ]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([\\w_@.%*?+-]|\\\\ )*(?=/)"+                              , reCompiled =+                                  Just (compileRegex True "([\\w_@.%*?+-]|\\\\ )*(?=/)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "~\\w*"+                              , reCompiled = Just (compileRegex True "~\\w*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/([\\w_@.%*?+-]|\\\\ )*(?=([\\s/):;$`'\"]|$))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "/([\\w_@.%*?+-]|\\\\ )*(?=([\\s/):;$`'\"]|$))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindStrings"+          , Context+              { cName = "FindStrings"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "StringSQ" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "StringDQ" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "StringEsc" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "StringDQ" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindSubstitutions"+          , Context+              { cName = "FindSubstitutions"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[A-Za-z_][A-Za-z0-9_]*\\["+                              , reCompiled =+                                  Just (compileRegex True "\\$[A-Za-z_][A-Za-z0-9_]*\\[")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "Subscript" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[A-Za-z_][A-Za-z0-9_]*"+                              , reCompiled = Just (compileRegex True "\\$[A-Za-z_][A-Za-z0-9_]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[*@#?$!_0-9-]"+                              , reCompiled = Just (compileRegex True "\\$[*@#?$!_0-9-]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\{[*@#?$!_0-9-]\\}"+                              , reCompiled = Just (compileRegex True "\\$\\{[*@#?$!_0-9-]\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\{#[A-Za-z_][A-Za-z0-9_]*\\}"+                              , reCompiled =+                                  Just (compileRegex True "\\$\\{#[A-Za-z_][A-Za-z0-9_]*\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\{![A-Za-z_][A-Za-z0-9_]*\\*?\\}"+                              , reCompiled =+                                  Just (compileRegex True "\\$\\{![A-Za-z_][A-Za-z0-9_]*\\*?\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\{[A-Za-z_][A-Za-z0-9_]*"+                              , reCompiled =+                                  Just (compileRegex True "\\$\\{[A-Za-z_][A-Za-z0-9_]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "VarBrace" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\{[*@#?$!_0-9-](?=[:#%/])"+                              , reCompiled =+                                  Just (compileRegex True "\\$\\{[*@#?$!_0-9-](?=[:#%/])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "VarBrace" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "$(("+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "ExprDblParenSubst" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "SubstBackq" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[`$\\\\]"+                              , reCompiled = Just (compileRegex True "\\\\[`$\\\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindTests"+          , Context+              { cName = "FindTests"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-[rwxXeozsfdlbcpSugktRLDIFNZ](?=\\s)"+                              , reCompiled =+                                  Just (compileRegex True "-[rwxXeozsfdlbcpSugktRLDIFNZ](?=\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-[AMCUG]:?(?=\\s)"+                              , reCompiled = Just (compileRegex True "-[AMCUG]:?(?=\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-P[0-7]{,3}:?(?=\\s)"+                              , reCompiled = Just (compileRegex True "-P[0-7]{,3}:?(?=\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([|&=><])\\1"+                              , reCompiled = Just (compileRegex True "([|&=><])\\1")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[|^&><+\\-*/%!~]"+                              , reCompiled = Just (compileRegex True "[|^&><+\\-*/%!~]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([!=]~|[!><]=)"+                              , reCompiled = Just (compileRegex True "([!=]~|[!><]=)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FunctionDef"+          , Context+              { cName = "FunctionDef"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+[A-Za-z_:][A-Za-z0-9_:#%@-]*(\\s*\\(\\))?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\s+[A-Za-z_:][A-Za-z0-9_:#%@-]*(\\s*\\(\\))?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "Group"+          , Context+              { cName = "Group"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindAll" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "HereDoc"+          , Context+              { cName = "HereDoc"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<-\\s*\"([|&;()<>\\s]+)\")"+                              , reCompiled =+                                  Just (compileRegex True "(<<-\\s*\"([|&;()<>\\s]+)\")")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "HereDocIQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<-\\s*'([|&;()<>\\s]+)')"+                              , reCompiled =+                                  Just (compileRegex True "(<<-\\s*'([|&;()<>\\s]+)')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "HereDocIQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<-\\s*\\\\([|&;()<>\\s]+))"+                              , reCompiled =+                                  Just (compileRegex True "(<<-\\s*\\\\([|&;()<>\\s]+))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "HereDocIQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<-\\s*([|&;()<>\\s]+))"+                              , reCompiled = Just (compileRegex True "(<<-\\s*([|&;()<>\\s]+))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "HereDocINQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<\\s*\"([|&;()<>\\s]+)\")"+                              , reCompiled =+                                  Just (compileRegex True "(<<\\s*\"([|&;()<>\\s]+)\")")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "HereDocQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<\\s*'([|&;()<>\\s]+)')"+                              , reCompiled = Just (compileRegex True "(<<\\s*'([|&;()<>\\s]+)')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "HereDocQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<\\s*\\\\([|&;()<>\\s]+))"+                              , reCompiled =+                                  Just (compileRegex True "(<<\\s*\\\\([|&;()<>\\s]+))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "HereDocQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<\\s*([|&;()<>\\s]+))"+                              , reCompiled = Just (compileRegex True "(<<\\s*([|&;()<>\\s]+))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "HereDocNQ" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<<"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "HereDocINQ"+          , Context+              { cName = "HereDocINQ"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1" , reCompiled = Nothing , reCaseSensitive = True }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "HereDocRemainder" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*%2[\\s;]*$"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "HereDocIQ"+          , Context+              { cName = "HereDocIQ"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1" , reCompiled = Nothing , reCaseSensitive = True }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "HereDocRemainder" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*%2[\\s;]*$"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "HereDocNQ"+          , Context+              { cName = "HereDocNQ"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1" , reCompiled = Nothing , reCaseSensitive = True }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "HereDocRemainder" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%2[\\s;]*$"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "HereDocQ"+          , Context+              { cName = "HereDocQ"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1" , reCompiled = Nothing , reCaseSensitive = True }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "HereDocRemainder" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%2[\\s;]*$"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "HereDocRemainder"+          , Context+              { cName = "HereDocRemainder"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindAll" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ProcessSubst"+          , Context+              { cName = "ProcessSubst"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindCommentsParen" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindCommands" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Start"+          , Context+              { cName = "Start"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindAll" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "StringDQ"+          , Context+              { cName = "StringDQ"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[`\"\\\\$\\n]"+                              , reCompiled = Just (compileRegex True "\\\\[`\"\\\\$\\n]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindSubstitutions" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "StringEsc"+          , Context+              { cName = "StringEsc"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[abefnrtv\\\\']"+                              , reCompiled = Just (compileRegex True "\\\\[abefnrtv\\\\']")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\([0-7]{1,3}|x[A-Fa-f0-9]{1,2}|c.)"+                              , reCompiled =+                                  Just (compileRegex True "\\\\([0-7]{1,3}|x[A-Fa-f0-9]{1,2}|c.)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "StringSQ"+          , Context+              { cName = "StringSQ"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SubShell"+          , Context+              { cName = "SubShell"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindAll" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Subscript"+          , Context+              { cName = "Subscript"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindStrings" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindSubstitutions" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindOthers" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SubstBackq"+          , Context+              { cName = "SubstBackq"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindCommentsBackq" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindCommands" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SubstCommand"+          , Context+              { cName = "SubstCommand"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindCommentsParen" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindCommands" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SubstFile"+          , Context+              { cName = "SubstFile"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindCommentsParen" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Switch"+          , Context+              { cName = "Switch"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\scase\\b"+                              , reCompiled = Just (compileRegex True "\\scase\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "SwitchCase" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\sdefault\\b"+                              , reCompiled = Just (compileRegex True "\\sdefault\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "SwitchDefault" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bendsw(?=$|[\\s;)])"+                              , reCompiled = Just (compileRegex True "\\bendsw(?=$|[\\s;)])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SwitchCase"+          , Context+              { cName = "SwitchCase"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "SwitchExpr" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SwitchDefault"+          , Context+              { cName = "SwitchDefault"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "SwitchExpr" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SwitchExpr"+          , Context+              { cName = "SwitchExpr"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\sbreaksw\\b"+                              , reCompiled = Just (compileRegex True "\\sbreaksw\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\scase\\b"+                              , reCompiled = Just (compileRegex True "\\scase\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindAll" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "VarBrace"+          , Context+              { cName = "VarBrace"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "Subscript" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindStrings" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindSubstitutions" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "VarName"+          , Context+              { cName = "VarName"+              , cSyntax = "Tcsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-[A-Za-z0-9]+"+                              , reCompiled = Just (compileRegex True "-[A-Za-z0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "--[a-z][A-Za-z0-9_-]*"+                              , reCompiled = Just (compileRegex True "--[a-z][A-Za-z0-9_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[A-Za-z_][A-Za-z0-9_]*"+                              , reCompiled = Just (compileRegex True "\\b[A-Za-z_][A-Za-z0-9_]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "Subscript" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Tcsh" , "Assign" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Tcsh" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^]})|;`&><]"+                              , reCompiled = Just (compileRegex True "[^]})|;`&><]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Matthew Woehlke (mw_triad@users.sourceforge.net)"+  , sVersion = "1"+  , sLicense = "LGPL"+  , sExtensions =+      [ "*.csh"+      , "*.tcsh"+      , "csh.cshrc"+      , "csh.login"+      , ".tcshrc"+      , ".cshrc"+      , ".login"+      ]+  , sStartingContext = "Start"+  }
+ src/Skylighting/Syntax/Texinfo.hs view
@@ -0,0 +1,288 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Texinfo (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex++syntax :: Syntax+syntax = Syntax+  { sName = "Texinfo"+  , sFilename = "texinfo.xml"+  , sShortname = "Texinfo"+  , sContexts =+      fromList+        [ ( "Normal Text"+          , Context+              { cName = "Normal Text"+              , cSyntax = "Texinfo"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@c(omment)?\\b"+                              , reCompiled = Just (compileRegex True "@c(omment)?\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Texinfo" , "singleLineComment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@ignore\\b"+                              , reCompiled = Just (compileRegex True "@ignore\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Texinfo" , "multiLineComment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@node\\b"+                              , reCompiled = Just (compileRegex True "@node\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Texinfo" , "nodeFolding" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@(menu|smallexample|table|multitable)\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex True "@(menu|smallexample|table|multitable)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Texinfo" , "folding" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@[\\w]+(\\{([\\w]+[\\s]*)+\\})?"+                              , reCompiled =+                                  Just (compileRegex True "@[\\w]+(\\{([\\w]+[\\s]*)+\\})?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "folding"+          , Context+              { cName = "folding"+              , cSyntax = "Texinfo"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@end (menu|smallexample|table|multitable)\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "@end (menu|smallexample|table|multitable)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Texinfo" , "Normal Text" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "multiLineComment"+          , Context+              { cName = "multiLineComment"+              , cSyntax = "Texinfo"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "@end ignore"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "nodeFolding"+          , Context+              { cName = "nodeFolding"+              , cSyntax = "Texinfo"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@node\\b"+                              , reCompiled = Just (compileRegex True "@node\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Texinfo" , "Normal Text" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "singleLineComment"+          , Context+              { cName = "singleLineComment"+              , cSyntax = "Texinfo"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Daniel Franke (franke.daniel@gmail.com)"+  , sVersion = "1"+  , sLicense = "LGPL"+  , sExtensions = [ "*.texi" ]+  , sStartingContext = "Normal Text"+  }
+ src/Skylighting/Syntax/Verilog.hs view
@@ -0,0 +1,882 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Verilog (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Verilog"+  , sFilename = "verilog.xml"+  , sShortname = "Verilog"+  , sContexts =+      fromList+        [ ( "Block name"+          , Context+              { cName = "Block name"+              , cSyntax = "Verilog"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Commentar 1"+          , Context+              { cName = "Commentar 1"+              , cSyntax = "Verilog"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Commentar 2"+          , Context+              { cName = "Commentar 2"+              , cSyntax = "Verilog"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Commentar/Preprocessor"+          , Context+              { cName = "Commentar/Preprocessor"+              , cSyntax = "Verilog"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal"+          , Context+              { cName = "Normal"+              , cSyntax = "Verilog"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "begin\\ *:"+                              , reCompiled = Just (compileRegex True "begin\\ *:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Verilog" , "Block name" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "fork\\ *:"+                              , reCompiled = Just (compileRegex True "fork\\ *:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Verilog" , "Block name" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "begin"+                               , "case"+                               , "casex"+                               , "casez"+                               , "fork"+                               , "function"+                               , "generate"+                               , "module"+                               , "task"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "end"+                               , "endcase"+                               , "endfunction"+                               , "endgenerate"+                               , "endmodule"+                               , "endtask"+                               , "join"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "always"+                               , "assign"+                               , "cell"+                               , "config"+                               , "deassign"+                               , "default"+                               , "defparam"+                               , "design"+                               , "disable"+                               , "edge"+                               , "else"+                               , "endconfig"+                               , "endspecify"+                               , "endtable"+                               , "for"+                               , "force"+                               , "forever"+                               , "if"+                               , "ifnone"+                               , "initial"+                               , "instance"+                               , "liblist"+                               , "library"+                               , "macromodule"+                               , "negedge"+                               , "posedge"+                               , "release"+                               , "repeat"+                               , "specify"+                               , "specparam"+                               , "table"+                               , "use"+                               , "wait"+                               , "while"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "automatic"+                               , "event"+                               , "genvar"+                               , "inout"+                               , "input"+                               , "integer"+                               , "localparam"+                               , "output"+                               , "parameter"+                               , "real"+                               , "realtime"+                               , "reg"+                               , "scalared"+                               , "signed"+                               , "supply0"+                               , "supply1"+                               , "time"+                               , "tri"+                               , "tri0"+                               , "tri1"+                               , "triand"+                               , "trior"+                               , "trireg"+                               , "vectored"+                               , "wand"+                               , "wire"+                               , "wor"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "highz0"+                               , "highz1"+                               , "large"+                               , "medium"+                               , "pull0"+                               , "pull1"+                               , "small"+                               , "strong0"+                               , "strong1"+                               , "weak0"+                               , "weak1"+                               ])+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "and"+                               , "buf"+                               , "bufif0"+                               , "bufif1"+                               , "cmos"+                               , "nand"+                               , "nmos"+                               , "nor"+                               , "not"+                               , "notif0"+                               , "notif1"+                               , "or"+                               , "pmos"+                               , "pulldown"+                               , "pullup"+                               , "rcmos"+                               , "rnmos"+                               , "rpmos"+                               , "rtran"+                               , "rtranif0"+                               , "rtranif1"+                               , "tran"+                               , "tranif0"+                               , "tranif1"+                               , "xnor"+                               , "xor"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\d_]*'d[\\d_]+"+                              , reCompiled = Just (compileRegex True "[\\d_]*'d[\\d_]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\d_]*'o[0-7xXzZ_]+"+                              , reCompiled = Just (compileRegex True "[\\d_]*'o[0-7xXzZ_]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\d_]*'h[\\da-fA-FxXzZ_]+"+                              , reCompiled =+                                  Just (compileRegex True "[\\d_]*'h[\\da-fA-FxXzZ_]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\d_]*'b[01_zZxX]+"+                              , reCompiled = Just (compileRegex True "[\\d_]*'b[01_zZxX]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[a-zA-Z0-9_, \\t]+\\s*:"+                              , reCompiled = Just (compileRegex True "[a-zA-Z0-9_, \\t]+\\s*:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Verilog" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Verilog" , "Commentar 1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Verilog" , "Commentar 2" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "!%&()+,-<=+/:;>?[]^{|}~@"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Verilog" , "Preprocessor" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\`[a-zA-Z_]+\\w*"+                              , reCompiled = Just (compileRegex True "\\`[a-zA-Z_]+\\w*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[a-zA-Z_]+\\w*"+                              , reCompiled = Just (compileRegex True "\\$[a-zA-Z_]+\\w*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "#[\\d_]+"+                              , reCompiled = Just (compileRegex True "#[\\d_]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Port"+          , Context+              { cName = "Port"+              , cSyntax = "Verilog"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Preprocessor"+          , Context+              { cName = "Preprocessor"+              , cSyntax = "Verilog"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Verilog" , "Some Context" ) ]+                      }+                  , Rule+                      { rMatcher = RangeDetect '"' '"'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = RangeDetect '<' '>'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Verilog" , "Commentar 1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "Verilog" , "Commentar/Preprocessor" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Some Context"+          , Context+              { cName = "Some Context"+              , cSyntax = "Verilog"+              , cRules = []+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Some Context2"+          , Context+              { cName = "Some Context2"+              , cSyntax = "Verilog"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "#endif"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Verilog"+              , cRules =+                  [ Rule+                      { rMatcher = LineContinue+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Verilog" , "Some Context" ) ]+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor =+      "Yevgen Voronenko (ysv22@drexel.edu), Ryan Dalzell (ryan@tullyroan.com)"+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.v" , "*.V" , "*.vl" ]+  , sStartingContext = "Normal"+  }
+ src/Skylighting/Syntax/Vhdl.hs view
@@ -0,0 +1,3608 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Vhdl (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "VHDL"+  , sFilename = "vhdl.xml"+  , sShortname = "Vhdl"+  , sContexts =+      fromList+        [ ( "arch_decl"+          , Context+              { cName = "arch_decl"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "attribute" , "constant" , "signal" , "type" , "variable" ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "signal" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "function"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "archfunc1" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "component"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "entity" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "begin"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "arch_start"+          , Context+              { cName = "arch_start"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)is\\b"+                              , reCompiled = Just (compileRegex False "(\\b)is\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "arch_decl" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)%2\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)%4\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "archfunc1"+          , Context+              { cName = "archfunc1"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)begin\\b"+                              , reCompiled = Just (compileRegex False "(\\b)begin\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "archfunc2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)end(\\s+function)?(\\s+%2)?\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)%2\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "archfunc2"+          , Context+              { cName = "archfunc2"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)end(\\s+function)?\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)begin\\b"+                              , reCompiled = Just (compileRegex False "(\\b)begin\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "proc_rules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "architecture_main"+          , Context+              { cName = "architecture_main"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b)architecture\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s+of\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s+is"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "arch_start" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)end(\\s+architecture)?(\\s+%2)?\\s*;"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b)end(\\s+architecture)?(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s*;"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "detect_arch_parts" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "attribute"+          , Context+              { cName = "attribute"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "quot in att" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "quot in att" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ' '+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = AnyChar ")=<>"+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = BaseNTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "case1"+          , Context+              { cName = "case1"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)is\\b"+                              , reCompiled = Just (compileRegex False "(\\b)is\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "case2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet False [ "case" , "when" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "case2"+          , Context+              { cName = "case2"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b)end\\s+case(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?\\s*;"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "(\\b)end\\s+case(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?\\s*;")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b)when(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "caseWhen" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "proc_rules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "caseWhen"+          , Context+              { cName = "caseWhen"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '=' '>'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "caseWhen2" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)when\\b"+                              , reCompiled = Just (compileRegex False "(\\b)when\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)%2\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "proc_rules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "caseWhen2"+          , Context+              { cName = "caseWhen2"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*when\\b"+                              , reCompiled = Just (compileRegex False "\\s*when\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*end\\s+case\\b"+                              , reCompiled = Just (compileRegex False "\\s*end\\s+case\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "proc_rules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "comment"+          , Context+              { cName = "comment"+              , cSyntax = "VHDL"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "conf_decl"+          , Context+              { cName = "conf_decl"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "for"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "conf_for" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "end"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "conf_for"+          , Context+              { cName = "conf_for"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "for"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "conf_for" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "end(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "end(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "conf_start"+          , Context+              { cName = "conf_start"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)is\\b"+                              , reCompiled = Just (compileRegex False "(\\b)is\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "conf_decl" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)%2\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)%4\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "configuration"+          , Context+              { cName = "configuration"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b)configuration\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s+of\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s+is"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "conf_start" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)end(\\s+configuration)?(\\s+%2)?\\s*;"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b)end(\\s+configuration)?(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s*;"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "detect_arch_parts"+          , Context+              { cName = "detect_arch_parts"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b)(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b\\s*:\\s*)(if|for).*\\s+generate\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "generate1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b)(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b\\s*:\\s*)?process\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "process1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b)(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s*:\\s*((entity\\s+)?(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)(\\.\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?)"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "instance" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "entity"+          , Context+              { cName = "entity"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "entity_main" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "entity_main"+          , Context+              { cName = "entity_main"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)end(\\s+(entity|component))?(\\s+%1)?\\s*;"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b)end(\\s+(entity|component))?(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?\\s*;"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "generic"+                              , reCompiled = Just (compileRegex False "generic")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "port"+                              , reCompiled = Just (compileRegex False "port")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "forwhile1"+          , Context+              { cName = "forwhile1"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)loop\\b"+                              , reCompiled = Just (compileRegex False "(\\b)loop\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "forwhile2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)%3\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)(for|while)\\b"+                              , reCompiled = Just (compileRegex False "(\\b)(for|while)\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "forwhile2"+          , Context+              { cName = "forwhile2"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)begin\\b"+                              , reCompiled = Just (compileRegex False "(\\b)begin\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b)end\\s+loop(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "(\\b)end\\s+loop(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "proc_rules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "generalDetection"+          , Context+              { cName = "generalDetection"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "bit"+                               , "bit_vector"+                               , "boolean"+                               , "boolean_vector"+                               , "character"+                               , "delay_length"+                               , "file_open_kind"+                               , "file_open_status"+                               , "integer"+                               , "integer_vector"+                               , "line"+                               , "mux_bit"+                               , "mux_vector"+                               , "natural"+                               , "positive"+                               , "qsim_12state"+                               , "qsim_12state_vector"+                               , "qsim_state"+                               , "qsim_state_vector"+                               , "qsim_strength"+                               , "real"+                               , "real_vector"+                               , "reg_bit"+                               , "reg_vector"+                               , "severity_level"+                               , "side"+                               , "signed"+                               , "std_logic"+                               , "std_logic_vector"+                               , "std_ulogic"+                               , "std_ulogic_vector"+                               , "string"+                               , "text"+                               , "time"+                               , "time_vector"+                               , "unresolved_signed"+                               , "unresolved_unsigned"+                               , "unsigned"+                               , "ux01"+                               , "ux01z"+                               , "width"+                               , "wor_bit"+                               , "wor_vector"+                               , "x01"+                               , "x01z"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False [ "fs" , "hr" , "min" , "ms" , "ns" , "ps" , "sec" , "us" ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "attribute" , "constant" , "signal" , "type" , "variable" ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "signal" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet False [ "downto" , "others" , "to" ])+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "abs"+                               , "access"+                               , "after"+                               , "alias"+                               , "all"+                               , "and"+                               , "array"+                               , "assert"+                               , "assume"+                               , "assume_guarantee"+                               , "attribute"+                               , "begin"+                               , "block"+                               , "body"+                               , "buffer"+                               , "bus"+                               , "component"+                               , "constant"+                               , "context"+                               , "cover"+                               , "default"+                               , "disconnect"+                               , "downto"+                               , "end"+                               , "error"+                               , "exit"+                               , "failure"+                               , "fairness"+                               , "falling_edge"+                               , "file"+                               , "for"+                               , "force"+                               , "function"+                               , "generate"+                               , "generic"+                               , "group"+                               , "guarded"+                               , "impure"+                               , "in"+                               , "inertial"+                               , "inout"+                               , "is"+                               , "label"+                               , "linkage"+                               , "literal"+                               , "map"+                               , "mod"+                               , "nand"+                               , "new"+                               , "next"+                               , "nor"+                               , "not"+                               , "note"+                               , "null"+                               , "of"+                               , "on"+                               , "open"+                               , "or"+                               , "others"+                               , "out"+                               , "parameter"+                               , "port"+                               , "postponed"+                               , "procedure"+                               , "process"+                               , "property"+                               , "protected"+                               , "pure"+                               , "range"+                               , "record"+                               , "register"+                               , "reject"+                               , "release"+                               , "rem"+                               , "report"+                               , "return"+                               , "rising_edge"+                               , "rol"+                               , "ror"+                               , "select"+                               , "sequence"+                               , "severity"+                               , "shared"+                               , "signal"+                               , "sla"+                               , "sll"+                               , "sra"+                               , "srl"+                               , "strong"+                               , "subtype"+                               , "to"+                               , "transport"+                               , "type"+                               , "unaffected"+                               , "units"+                               , "until"+                               , "variable"+                               , "vmode"+                               , "vprop"+                               , "vunit"+                               , "wait"+                               , "warning"+                               , "when"+                               , "with"+                               , "xnor"+                               , "xor"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "generate1"+          , Context+              { cName = "generate1"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)(generate|loop)\\b"+                              , reCompiled = Just (compileRegex False "(\\b)(generate|loop)\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "generate2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)%3\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)(for|if|while)\\b"+                              , reCompiled = Just (compileRegex False "(\\b)(for|if|while)\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "generate2"+          , Context+              { cName = "generate2"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)begin\\b"+                              , reCompiled = Just (compileRegex False "(\\b)begin\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b)end\\s+(generate|loop)(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "(\\b)end\\s+(generate|loop)(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "detect_arch_parts" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "if"+          , Context+              { cName = "if"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b)end\\s+if(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?\\s*;"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "(\\b)end\\s+if(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?\\s*;")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "proc_rules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet False [ "else" , "elsif" , "if" , "then" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "if_start"+          , Context+              { cName = "if_start"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)then\\b"+                              , reCompiled = Just (compileRegex False "(\\b)then\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "if" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "instance"+          , Context+              { cName = "instance"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)%4\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)%3\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)(port|generic)\\s+map\\s*\\("+                              , reCompiled =+                                  Just (compileRegex True "(\\b)(port|generic)\\s+map\\s*\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "instanceMap" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "instanceInnerPar"+          , Context+              { cName = "instanceInnerPar"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "instanceInnerPar" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "instanceMap"+          , Context+              { cName = "instanceMap"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = AnyChar "<;:"+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "instanceInnerPar" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "package"+          , Context+              { cName = "package"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)package\\b"+                              , reCompiled = Just (compileRegex False "(\\b)package\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)is\\b"+                              , reCompiled = Just (compileRegex False "(\\b)is\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "packagemain" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)%2\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)end(\\s+package)?(\\s+%2)?\\s*;"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "packagebody"+          , Context+              { cName = "packagebody"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)package\\b"+                              , reCompiled = Just (compileRegex False "(\\b)package\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)is\\b"+                              , reCompiled = Just (compileRegex False "(\\b)is\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "packagebodymain" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)%2\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)end(\\s+package)?(\\s+%2)?\\s*;"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "packagebodyfunc1"+          , Context+              { cName = "packagebodyfunc1"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)begin\\b"+                              , reCompiled = Just (compileRegex False "(\\b)begin\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "packagebodyfunc2" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)end(\\s+function)?(\\s+%2)?\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)%2\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "packagebodyfunc2"+          , Context+              { cName = "packagebodyfunc2"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)end(\\s+function)?\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)begin\\b"+                              , reCompiled = Just (compileRegex False "(\\b)begin\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "proc_rules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "packagebodymain"+          , Context+              { cName = "packagebodymain"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)end\\s+package\\b"+                              , reCompiled = Just (compileRegex False "(\\b)end\\s+package\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b)function\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "packagebodyfunc1" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "packagefunction"+          , Context+              { cName = "packagefunction"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b)\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b\\b"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "(\\b)\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "packagemain"+          , Context+              { cName = "packagemain"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)end\\b"+                              , reCompiled = Just (compileRegex False "(\\b)end\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)function\\b"+                              , reCompiled = Just (compileRegex False "(\\b)function\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "packagefunction" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "preDetection"+          , Context+              { cName = "preDetection"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '-' '-'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "string" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "[&><=:+\\-*\\/|].,"+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "attribute" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "proc_rules"+          , Context+              { cName = "proc_rules"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b)\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b(?=\\s*:(?!=))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       False+                                       "(\\b)\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b(?=\\s*:(?!=))")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)if\\b"+                              , reCompiled = Just (compileRegex False "(\\b)if\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "if_start" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)case\\b"+                              , reCompiled = Just (compileRegex False "(\\b)case\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "case1" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b)((\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s*:\\s*)?((for|while)\\s+.+\\s+)loop\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "forwhile1" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "process1"+          , Context+              { cName = "process1"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)end\\s+process(\\s+%3)?"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b)end\\s+process(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)process\\b"+                              , reCompiled = Just (compileRegex False "(\\b)process\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(\\b)begin\\b"+                              , reCompiled = Just (compileRegex False "(\\b)begin\\b")+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "proc_rules" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "quot in att"+          , Context+              { cName = "quot in att"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = BaseNTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "signal"+          , Context+              { cName = "signal"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "VHDL" , "generalDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "start"+          , Context+              { cName = "start"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "VHDL" , "preDetection" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b)architecture\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "architecture_main" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "entity"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "entity" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b)package\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s+is\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "package" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b)package\\s+body\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s+is\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "packagebody" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(\\b)configuration\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = False+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "VHDL" , "configuration" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet False [ "file" , "library" , "use" ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "string"+          , Context+              { cName = "string"+              , cSyntax = "VHDL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor =+      "Rocky Scaletta (rocky@purdue.edu), Stefan Endrullis (stefan@endrullis.de), Florent Ouchet (outchy@users.sourceforge.net), Chris Higgs (chiggs.99@gmail.com), Jan Michel (jan@mueschelsoft.de), Luigi Calligaris (luigi.calligaris@stfc.ac.uk)"+  , sVersion = "2"+  , sLicense = ""+  , sExtensions = [ "*.vhdl" , "*.vhd" ]+  , sStartingContext = "start"+  }
+ src/Skylighting/Syntax/Xml.hs view
@@ -0,0 +1,1105 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Xml (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex++syntax :: Syntax+syntax = Syntax+  { sName = "XML"+  , sFilename = "xml.xml"+  , sShortname = "Xml"+  , sContexts =+      fromList+        [ ( "Attribute"+          , Context+              { cName = "Attribute"+              , cSyntax = "XML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XML" , "Value" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CDATA"+          , Context+              { cName = "CDATA"+              , cSyntax = "XML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "]]>"+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "]]&gt;"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "XML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "-->"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-(-(?!->))+"+                              , reCompiled = Just (compileRegex True "-(-(?!->))+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype"+          , Context+              { cName = "Doctype"+              , cSyntax = "XML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XML" , "Doctype Internal Subset" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Internal Subset"+          , Context+              { cName = "Doctype Internal Subset"+              , cSyntax = "XML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<!(ELEMENT|ENTITY|ATTLIST|NOTATION)\\b"+                              , reCompiled =+                                  Just (compileRegex True "<!(ELEMENT|ENTITY|ATTLIST|NOTATION)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XML" , "Doctype Markupdecl" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XML" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\?[\\w:_-]*"+                              , reCompiled = Just (compileRegex True "<\\?[\\w:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XML" , "PI" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "XML" , "FindPEntityRefs" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Markupdecl"+          , Context+              { cName = "Doctype Markupdecl"+              , cSyntax = "XML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XML" , "Doctype Markupdecl DQ" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XML" , "Doctype Markupdecl SQ" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Markupdecl DQ"+          , Context+              { cName = "Doctype Markupdecl DQ"+              , cSyntax = "XML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "XML" , "FindPEntityRefs" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Markupdecl SQ"+          , Context+              { cName = "Doctype Markupdecl SQ"+              , cSyntax = "XML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "XML" , "FindPEntityRefs" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "El Content"+          , Context+              { cName = "El Content"+              , cSyntax = "XML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</(?![0-9])[\\w_:][\\w.:_-]*"+                              , reCompiled =+                                  Just (compileRegex True "</(?![0-9])[\\w_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XML" , "El End" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "XML" , "FindXML" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "El End"+          , Context+              { cName = "El End"+              , cSyntax = "XML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Element"+          , Context+              { cName = "Element"+              , cSyntax = "XML"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XML" , "El Content" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(?![0-9])[\\w_:][\\w.:_-]*"+                              , reCompiled =+                                  Just (compileRegex True "(?![0-9])[\\w_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "XML" , "Attribute" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+(?![0-9])[\\w_:][\\w.:_-]*"+                              , reCompiled =+                                  Just (compileRegex True "\\s+(?![0-9])[\\w_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XML" , "Attribute" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindEntityRefs"+          , Context+              { cName = "FindEntityRefs"+              , cSyntax = "XML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "&(#[0-9]+|#[xX][0-9A-Fa-f]+|(?![0-9])[\\w_:][\\w.:_-]*);"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "&(#[0-9]+|#[xX][0-9A-Fa-f]+|(?![0-9])[\\w_:][\\w.:_-]*);")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "&<"+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindPEntityRefs"+          , Context+              { cName = "FindPEntityRefs"+              , cSyntax = "XML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "&(#[0-9]+|#[xX][0-9A-Fa-f]+|(?![0-9])[\\w_:][\\w.:_-]*);"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "&(#[0-9]+|#[xX][0-9A-Fa-f]+|(?![0-9])[\\w_:][\\w.:_-]*);")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%(?![0-9])[\\w_:][\\w.:_-]*;"+                              , reCompiled =+                                  Just (compileRegex True "%(?![0-9])[\\w_:][\\w.:_-]*;")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "&%"+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindXML"+          , Context+              { cName = "FindXML"+              , cSyntax = "XML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XML" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<![CDATA["+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XML" , "CDATA" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<!DOCTYPE\\s+"+                              , reCompiled = Just (compileRegex True "<!DOCTYPE\\s+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XML" , "Doctype" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\?[\\w:_-]*"+                              , reCompiled = Just (compileRegex True "<\\?[\\w:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XML" , "PI" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<(?![0-9])[\\w_:][\\w.:_-]*"+                              , reCompiled =+                                  Just (compileRegex True "<(?![0-9])[\\w_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XML" , "Element" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "XML" , "FindEntityRefs" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "PI"+          , Context+              { cName = "PI"+              , cSyntax = "XML"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '?' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Start"+          , Context+              { cName = "Start"+              , cSyntax = "XML"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "XML" , "FindXML" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Value"+          , Context+              { cName = "Value"+              , cSyntax = "XML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XML" , "Value DQ" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XML" , "Value SQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Value DQ"+          , Context+              { cName = "Value DQ"+              , cSyntax = "XML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "XML" , "FindEntityRefs" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Value SQ"+          , Context+              { cName = "Value SQ"+              , cSyntax = "XML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "XML" , "FindEntityRefs" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Wilbert Berendsen (wilbert@kde.nl)"+  , sVersion = "5"+  , sLicense = "LGPL"+  , sExtensions =+      [ "*.docbook"+      , "*.xml"+      , "*.rc"+      , "*.daml"+      , "*.rdf"+      , "*.rss"+      , "*.xspf"+      , "*.xsd"+      , "*.svg"+      , "*.ui"+      , "*.kcfg"+      , "*.qrc"+      , "*.wsdl"+      , "*.scxml"+      ]+  , sStartingContext = "Start"+  }
+ src/Skylighting/Syntax/Xorg.hs view
@@ -0,0 +1,350 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Xorg (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex++syntax :: Syntax+syntax = Syntax+  { sName = "x.org Configuration"+  , sFilename = "xorg.xml"+  , sShortname = "Xorg"+  , sContexts =+      fromList+        [ ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "x.org Configuration"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Keyword"+          , Context+              { cName = "Keyword"+              , cSyntax = "x.org Configuration"+              , cRules =+                  [ Rule+                      { rMatcher = RangeDetect '"' '"'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = RangeDetect '\'' '\''+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\w\\d]+"+                              , reCompiled = Just (compileRegex True "[\\w\\d]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "x.org Configuration" , "Comment" ) ]+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Section"+          , Context+              { cName = "Section"+              , cSyntax = "x.org Configuration"+              , cRules =+                  [ Rule+                      { rMatcher = RangeDetect '"' '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "x.org Configuration" , "Section Content" ) ]+                      }+                  , Rule+                      { rMatcher = RangeDetect '\'' '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "x.org Configuration" , "Section Content" ) ]+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "x.org Configuration" , "Comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Section Content"+          , Context+              { cName = "Section Content"+              , cSyntax = "x.org Configuration"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "EndSection"+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "EndSubSection"+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "SubSection"+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "x.org Configuration" , "Section" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b\\w+\\b"+                              , reCompiled = Just (compileRegex True "\\b\\w+\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "x.org Configuration" , "Keyword" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "x.org Configuration" , "Comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "xorg"+          , Context+              { cName = "xorg"+              , cSyntax = "x.org Configuration"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "Section"+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = False+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "x.org Configuration" , "Section" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "x.org Configuration" , "Comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Jan Janssen (medhefgo@web.de)"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions = [ "xorg.conf" ]+  , sStartingContext = "xorg"+  }
+ src/Skylighting/Syntax/Xslt.hs view
@@ -0,0 +1,1901 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Xslt (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "xslt"+  , sFilename = "xslt.xml"+  , sShortname = "Xslt"+  , sContexts =+      fromList+        [ ( "CDATA"+          , Context+              { cName = "CDATA"+              , cSyntax = "xslt"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "]]>"+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "]]&gt;"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype"+          , Context+              { cName = "Doctype"+              , cSyntax = "xslt"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "Doctype Internal Subset" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Internal Subset"+          , Context+              { cName = "Doctype Internal Subset"+              , cSyntax = "xslt"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<!(ELEMENT|ENTITY|ATTLIST|NOTATION)\\b"+                              , reCompiled =+                                  Just (compileRegex True "<!(ELEMENT|ENTITY|ATTLIST|NOTATION)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "Doctype Markupdecl" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\?[\\w:_-]*"+                              , reCompiled = Just (compileRegex True "<\\?[\\w:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "PI" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "xslt" , "FindPEntityRefs" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Markupdecl"+          , Context+              { cName = "Doctype Markupdecl"+              , cSyntax = "xslt"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "Doctype Markupdecl DQ" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "Doctype Markupdecl SQ" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Markupdecl DQ"+          , Context+              { cName = "Doctype Markupdecl DQ"+              , cSyntax = "xslt"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "xslt" , "FindPEntityRefs" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Markupdecl SQ"+          , Context+              { cName = "Doctype Markupdecl SQ"+              , cSyntax = "xslt"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "xslt" , "FindPEntityRefs" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindPEntityRefs"+          , Context+              { cName = "FindPEntityRefs"+              , cSyntax = "xslt"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%[A-Za-z_:][\\w.:_-]*;"+                              , reCompiled = Just (compileRegex True "%[A-Za-z_:][\\w.:_-]*;")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "&%"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "PI"+          , Context+              { cName = "PI"+              , cSyntax = "xslt"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '?' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "attrValue"+          , Context+              { cName = "attrValue"+              , cSyntax = "xslt"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "string" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "sqstring" ) ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "attributes"+          , Context+              { cName = "attributes"+              , cSyntax = "xslt"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*=\\s*"+                              , reCompiled = Just (compileRegex True "\\s*=\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "attrValue" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "comment"+          , Context+              { cName = "comment"+              , cSyntax = "xslt"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "-->"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-(-(?!->))+"+                              , reCompiled = Just (compileRegex True "-(-(?!->))+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(FIXME|TODO|HACK)"+                              , reCompiled = Just (compileRegex True "(FIXME|TODO|HACK)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "detectEntRef"+          , Context+              { cName = "detectEntRef"+              , cSyntax = "xslt"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "normalText"+          , Context+              { cName = "normalText"+              , cSyntax = "xslt"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<![CDATA["+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "CDATA" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<!DOCTYPE\\s+"+                              , reCompiled = Just (compileRegex True "<!DOCTYPE\\s+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "Doctype" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\?[\\w:_-]*"+                              , reCompiled = Just (compileRegex True "<\\?[\\w:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "PI" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "tagname" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "sqstring"+          , Context+              { cName = "sqstring"+              , cSyntax = "xslt"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "sqxpath" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "xslt" , "detectEntRef" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "sqxpath"+          , Context+              { cName = "sqxpath"+              , cSyntax = "xslt"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&()*+,./;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "boolean"+                               , "ceiling"+                               , "concat"+                               , "contains"+                               , "count"+                               , "current"+                               , "document"+                               , "element-available"+                               , "false"+                               , "floor"+                               , "format-number"+                               , "function-available"+                               , "generate-id"+                               , "id"+                               , "key"+                               , "lang"+                               , "last"+                               , "local-name"+                               , "name"+                               , "namespace-uri"+                               , "normalize-space"+                               , "not"+                               , "number"+                               , "position"+                               , "round"+                               , "starts-with"+                               , "string"+                               , "string-length"+                               , "substring"+                               , "substring-after"+                               , "substring-before"+                               , "sum"+                               , "system-property"+                               , "text"+                               , "translate"+                               , "true"+                               , "unparsed-entity-uri"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&()*+,./;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "abs"+                               , "adjust-date-to-timezone"+                               , "adjust-dateTime-to-timezone"+                               , "adjust-time-to-timezone"+                               , "avg"+                               , "base-uri"+                               , "codepoints-to-string"+                               , "collection"+                               , "compare"+                               , "current-date"+                               , "current-dateTime"+                               , "current-group"+                               , "current-grouping-key"+                               , "current-time"+                               , "data"+                               , "dateTime"+                               , "day-from-date"+                               , "day-from-dateTime"+                               , "days-from-duration"+                               , "deep-equal"+                               , "default-collation"+                               , "distinct-values"+                               , "doc"+                               , "document-uri"+                               , "empty"+                               , "ends-with"+                               , "error"+                               , "escape-uri"+                               , "exactly-one"+                               , "exists"+                               , "expanded-QName"+                               , "format-date"+                               , "format-dateTime"+                               , "format-time"+                               , "hours-from-dateTime"+                               , "hours-from-duration"+                               , "hours-from-time"+                               , "idref"+                               , "implicit-timezone"+                               , "in-scope-prefixes"+                               , "index-of"+                               , "input"+                               , "insert-before"+                               , "local-name-from-QName"+                               , "lower-case"+                               , "matches"+                               , "max"+                               , "min"+                               , "minutes-from-dateTime"+                               , "minutes-from-duration"+                               , "minutes-from-time"+                               , "month-from-date"+                               , "month-from-dateTime"+                               , "months-from-duration"+                               , "namespace-uri-for-prefix"+                               , "namespace-uri-from-QName"+                               , "node-kind"+                               , "node-name"+                               , "normalize-unicode"+                               , "one-or-more"+                               , "QName"+                               , "regex-group"+                               , "remove"+                               , "replace"+                               , "resolve-QName"+                               , "resolve-uri"+                               , "reverse"+                               , "root"+                               , "round-half-to-even"+                               , "seconds-from-dateTime"+                               , "seconds-from-duration"+                               , "seconds-from-time"+                               , "sequence-node-identical"+                               , "static-base-uri"+                               , "string-join"+                               , "string-to-codepoints"+                               , "subsequence"+                               , "subtract-dates-yielding-dayTimeDuration"+                               , "subtract-dates-yielding-yearMonthDuration"+                               , "subtract-dateTimes-yielding-dayTimeDuration"+                               , "subtract-dateTimes-yielding-yearMonthDuration"+                               , "timezone-from-date"+                               , "timezone-from-dateTime"+                               , "timezone-from-time"+                               , "tokenize"+                               , "trace"+                               , "unordered"+                               , "unparsed-entity-public-id"+                               , "unparsed-text"+                               , "upper-case"+                               , "year-from-date"+                               , "year-from-dateTime"+                               , "years-from-duration"+                               , "zero-or-one"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(ancestor|ancestor-or-self|attribute|child|descendant|descendant-or-self|following|following-sibling|namespace|parent|preceding|preceding-sibling|self)::"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(ancestor|ancestor-or-self|attribute|child|descendant|descendant-or-self|following|following-sibling|namespace|parent|preceding|preceding-sibling|self)::")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "xpathstring" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@[A-Za-z_:][\\w.:_-]*"+                              , reCompiled = Just (compileRegex True "@[A-Za-z_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[A-Za-z_:][\\w.:_-]*"+                              , reCompiled = Just (compileRegex True "\\$[A-Za-z_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Za-z_:][\\w.:_-]*"+                              , reCompiled = Just (compileRegex True "[A-Za-z_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "xslt" , "detectEntRef" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "sqxpathstring"+          , Context+              { cName = "sqxpathstring"+              , cSyntax = "xslt"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "xslt" , "detectEntRef" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "string"+          , Context+              { cName = "string"+              , cSyntax = "xslt"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "xpath" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "xslt" , "detectEntRef" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "tagname"+          , Context+              { cName = "tagname"+              , cSyntax = "xslt"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&()*+,./;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "xsl:apply-imports"+                               , "xsl:apply-templates"+                               , "xsl:attribute"+                               , "xsl:attribute-set"+                               , "xsl:call-template"+                               , "xsl:choose"+                               , "xsl:comment"+                               , "xsl:copy"+                               , "xsl:copy-of"+                               , "xsl:decimal-format"+                               , "xsl:element"+                               , "xsl:fallback"+                               , "xsl:for-each"+                               , "xsl:if"+                               , "xsl:import"+                               , "xsl:include"+                               , "xsl:key"+                               , "xsl:message"+                               , "xsl:namespace-alias"+                               , "xsl:number"+                               , "xsl:otherwise"+                               , "xsl:output"+                               , "xsl:param"+                               , "xsl:preserve-space"+                               , "xsl:processing-instruction"+                               , "xsl:sort"+                               , "xsl:strip-space"+                               , "xsl:stylesheet"+                               , "xsl:template"+                               , "xsl:text"+                               , "xsl:transform"+                               , "xsl:value-of"+                               , "xsl:variable"+                               , "xsl:when"+                               , "xsl:with-param"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "xattributes" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&()*+,./;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "xsl:analyze-string"+                               , "xsl:character-map"+                               , "xsl:document"+                               , "xsl:for-each-group"+                               , "xsl:function"+                               , "xsl:import-schema"+                               , "xsl:matching-substring"+                               , "xsl:namespace"+                               , "xsl:next-match"+                               , "xsl:non-matching-substring"+                               , "xsl:output-character"+                               , "xsl:perform-sort"+                               , "xsl:result-document"+                               , "xsl:sequence"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "xattributes" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*"+                              , reCompiled = Just (compileRegex True "\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "attributes" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "xattrValue"+          , Context+              { cName = "xattrValue"+              , cSyntax = "xslt"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "xpath" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "sqxpath" ) ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "xattributes"+          , Context+              { cName = "xattributes"+              , cSyntax = "xslt"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "select\\s*=\\s*"+                              , reCompiled = Just (compileRegex True "select\\s*=\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "xattrValue" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "test\\s*=\\s*"+                              , reCompiled = Just (compileRegex True "test\\s*=\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "xattrValue" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "match\\s*=\\s*"+                              , reCompiled = Just (compileRegex True "match\\s*=\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "xattrValue" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*=\\s*"+                              , reCompiled = Just (compileRegex True "\\s*=\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "attrValue" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "xpath"+          , Context+              { cName = "xpath"+              , cSyntax = "xslt"+              , cRules =+                  [ Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&()*+,./;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "boolean"+                               , "ceiling"+                               , "concat"+                               , "contains"+                               , "count"+                               , "current"+                               , "document"+                               , "element-available"+                               , "false"+                               , "floor"+                               , "format-number"+                               , "function-available"+                               , "generate-id"+                               , "id"+                               , "key"+                               , "lang"+                               , "last"+                               , "local-name"+                               , "name"+                               , "namespace-uri"+                               , "normalize-space"+                               , "not"+                               , "number"+                               , "position"+                               , "round"+                               , "starts-with"+                               , "string"+                               , "string-length"+                               , "substring"+                               , "substring-after"+                               , "substring-before"+                               , "sum"+                               , "system-property"+                               , "text"+                               , "translate"+                               , "true"+                               , "unparsed-entity-uri"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = False+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !\"%&()*+,./;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               False+                               [ "abs"+                               , "adjust-date-to-timezone"+                               , "adjust-dateTime-to-timezone"+                               , "adjust-time-to-timezone"+                               , "avg"+                               , "base-uri"+                               , "codepoints-to-string"+                               , "collection"+                               , "compare"+                               , "current-date"+                               , "current-dateTime"+                               , "current-group"+                               , "current-grouping-key"+                               , "current-time"+                               , "data"+                               , "dateTime"+                               , "day-from-date"+                               , "day-from-dateTime"+                               , "days-from-duration"+                               , "deep-equal"+                               , "default-collation"+                               , "distinct-values"+                               , "doc"+                               , "document-uri"+                               , "empty"+                               , "ends-with"+                               , "error"+                               , "escape-uri"+                               , "exactly-one"+                               , "exists"+                               , "expanded-QName"+                               , "format-date"+                               , "format-dateTime"+                               , "format-time"+                               , "hours-from-dateTime"+                               , "hours-from-duration"+                               , "hours-from-time"+                               , "idref"+                               , "implicit-timezone"+                               , "in-scope-prefixes"+                               , "index-of"+                               , "input"+                               , "insert-before"+                               , "local-name-from-QName"+                               , "lower-case"+                               , "matches"+                               , "max"+                               , "min"+                               , "minutes-from-dateTime"+                               , "minutes-from-duration"+                               , "minutes-from-time"+                               , "month-from-date"+                               , "month-from-dateTime"+                               , "months-from-duration"+                               , "namespace-uri-for-prefix"+                               , "namespace-uri-from-QName"+                               , "node-kind"+                               , "node-name"+                               , "normalize-unicode"+                               , "one-or-more"+                               , "QName"+                               , "regex-group"+                               , "remove"+                               , "replace"+                               , "resolve-QName"+                               , "resolve-uri"+                               , "reverse"+                               , "root"+                               , "round-half-to-even"+                               , "seconds-from-dateTime"+                               , "seconds-from-duration"+                               , "seconds-from-time"+                               , "sequence-node-identical"+                               , "static-base-uri"+                               , "string-join"+                               , "string-to-codepoints"+                               , "subsequence"+                               , "subtract-dates-yielding-dayTimeDuration"+                               , "subtract-dates-yielding-yearMonthDuration"+                               , "subtract-dateTimes-yielding-dayTimeDuration"+                               , "subtract-dateTimes-yielding-yearMonthDuration"+                               , "timezone-from-date"+                               , "timezone-from-dateTime"+                               , "timezone-from-time"+                               , "tokenize"+                               , "trace"+                               , "unordered"+                               , "unparsed-entity-public-id"+                               , "unparsed-text"+                               , "upper-case"+                               , "year-from-date"+                               , "year-from-dateTime"+                               , "years-from-duration"+                               , "zero-or-one"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString =+                                  "(ancestor|ancestor-or-self|attribute|child|descendant|descendant-or-self|following|following-sibling|namespace|parent|preceding|preceding-sibling|self)::"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True+                                       "(ancestor|ancestor-or-self|attribute|child|descendant|descendant-or-self|following|following-sibling|namespace|parent|preceding|preceding-sibling|self)::")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "xslt" , "sqxpathstring" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "@[A-Za-z_:][\\w.:_-]*"+                              , reCompiled = Just (compileRegex True "@[A-Za-z_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[A-Za-z_:][\\w.:_-]*"+                              , reCompiled = Just (compileRegex True "\\$[A-Za-z_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Za-z_:][\\w.:_-]*"+                              , reCompiled = Just (compileRegex True "[A-Za-z_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "xslt" , "detectEntRef" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "xpathstring"+          , Context+              { cName = "xpathstring"+              , cSyntax = "xslt"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "xslt" , "detectEntRef" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Peter Lammich (views@gmx.de)"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions = [ "*.xsl" , "*.xslt" ]+  , sStartingContext = "normalText"+  }
+ src/Skylighting/Syntax/Xul.hs view
@@ -0,0 +1,2316 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Xul (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "XUL"+  , sFilename = "xul.xml"+  , sShortname = "Xul"+  , sContexts =+      fromList+        [ ( "(Internal regex catch)"+          , Context+              { cName = "(Internal regex catch)"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*"+                              , reCompiled = Just (compileRegex True "\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "//(?=;)"+                              , reCompiled = Just (compileRegex True "//(?=;)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "JSComment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "Multi/inline Comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '/'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "(regex caret first check)" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "(charclass caret first check)"+          , Context+              { cName = "(charclass caret first check)"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '^'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "XUL" , "Regular Expression Character Class" ) ]+                      }+                  ]+              , cAttribute = FloatTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext =+                  [ Push ( "XUL" , "Regular Expression Character Class" ) ]+              , cDynamic = False+              }+          )+        , ( "(regex caret first check)"+          , Context+              { cName = "(regex caret first check)"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '^'+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "Regular Expression" ) ]+                      }+                  ]+              , cAttribute = FloatTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Push ( "XUL" , "Regular Expression" ) ]+              , cDynamic = False+              }+          )+        , ( "Attribute"+          , Context+              { cName = "Attribute"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "Value" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CDATA"+          , Context+              { cName = "CDATA"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = StringDetect "]]>"+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = StringDetect "]]&gt;"+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "//BEGIN"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "region_marker" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "//END"+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "region_marker" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "break"+                               , "case"+                               , "catch"+                               , "const"+                               , "continue"+                               , "default"+                               , "delete"+                               , "do"+                               , "else"+                               , "false"+                               , "finally"+                               , "for"+                               , "function"+                               , "if"+                               , "in"+                               , "new"+                               , "return"+                               , "switch"+                               , "throw"+                               , "true"+                               , "try"+                               , "typeof"+                               , "var"+                               , "void"+                               , "while"+                               , "with"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Number"+                               , "escape"+                               , "isFinite"+                               , "isNaN"+                               , "parseFloat"+                               , "parseInt"+                               , "reload"+                               , "taint"+                               , "unescape"+                               , "untaint"+                               , "write"+                               ])+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "Anchor"+                               , "Applet"+                               , "Area"+                               , "Array"+                               , "Boolean"+                               , "Button"+                               , "Checkbox"+                               , "Date"+                               , "FileUpload"+                               , "Form"+                               , "Frame"+                               , "Function"+                               , "Hidden"+                               , "Image"+                               , "Layer"+                               , "Link"+                               , "Math"+                               , "Max"+                               , "MimeType"+                               , "Min"+                               , "Object"+                               , "Password"+                               , "Plugin"+                               , "Radio"+                               , "RegExp"+                               , "Reset"+                               , "Screen"+                               , "Select"+                               , "String"+                               , "Text"+                               , "Textarea"+                               , "Window"+                               , "document"+                               , "navigator"+                               , "this"+                               , "window"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "E"+                               , "LN10"+                               , "LN2"+                               , "LOG10E"+                               , "LOG2E"+                               , "PI"+                               , "SQRT1_2"+                               , "SQRT2"+                               , "abs"+                               , "acos"+                               , "asin"+                               , "atan"+                               , "atan2"+                               , "ceil"+                               , "cos"+                               , "ctg"+                               , "exp"+                               , "floor"+                               , "log"+                               , "pow"+                               , "round"+                               , "sin"+                               , "sqrt"+                               , "tan"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "onAbort"+                               , "onBlur"+                               , "onChange"+                               , "onClick"+                               , "onError"+                               , "onFocus"+                               , "onLoad"+                               , "onMouseOut"+                               , "onMouseOver"+                               , "onReset"+                               , "onSelect"+                               , "onSubmit"+                               , "onUnload"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims =+                                  Data.Set.fromList "\t\n !%&()*+,-./:;<=>?[\\]^{|}~"+                              }+                            (makeWordSet+                               True+                               [ "MAX_VALUE"+                               , "MIN_VALUE"+                               , "NEGATIVE_INFINITY"+                               , "NaN"+                               , "POSITIVE_INFINITY"+                               , "URL"+                               , "UTC"+                               , "above"+                               , "action"+                               , "alert"+                               , "alinkColor"+                               , "anchor"+                               , "anchors"+                               , "appCodeName"+                               , "appName"+                               , "appVersion"+                               , "applets"+                               , "apply"+                               , "argument"+                               , "arguments"+                               , "arity"+                               , "availHeight"+                               , "availWidth"+                               , "back"+                               , "background"+                               , "below"+                               , "bgColor"+                               , "big"+                               , "blink"+                               , "blur"+                               , "bold"+                               , "border"+                               , "call"+                               , "caller"+                               , "charAt"+                               , "charCodeAt"+                               , "checked"+                               , "clearInterval"+                               , "clearTimeout"+                               , "click"+                               , "clip"+                               , "close"+                               , "closed"+                               , "colorDepth"+                               , "compile"+                               , "complete"+                               , "confirm"+                               , "constructor"+                               , "cookie"+                               , "current"+                               , "cursor"+                               , "data"+                               , "defaultChecked"+                               , "defaultSelected"+                               , "defaultStatus"+                               , "defaultValue"+                               , "description"+                               , "disableExternalCapture"+                               , "domain"+                               , "elements"+                               , "embeds"+                               , "enableExternalCapture"+                               , "enabledPlugin"+                               , "encoding"+                               , "eval"+                               , "exec"+                               , "fgColor"+                               , "filename"+                               , "find"+                               , "fixed"+                               , "focus"+                               , "fontcolor"+                               , "fontsize"+                               , "form"+                               , "formName"+                               , "forms"+                               , "forward"+                               , "frames"+                               , "fromCharCode"+                               , "getDate"+                               , "getDay"+                               , "getHours"+                               , "getMiliseconds"+                               , "getMinutes"+                               , "getMonth"+                               , "getSeconds"+                               , "getSelection"+                               , "getTime"+                               , "getTimezoneOffset"+                               , "getUTCDate"+                               , "getUTCDay"+                               , "getUTCFullYear"+                               , "getUTCHours"+                               , "getUTCMilliseconds"+                               , "getUTCMinutes"+                               , "getUTCMonth"+                               , "getUTCSeconds"+                               , "getYear"+                               , "global"+                               , "go"+                               , "hash"+                               , "height"+                               , "history"+                               , "home"+                               , "host"+                               , "hostname"+                               , "href"+                               , "hspace"+                               , "ignoreCase"+                               , "images"+                               , "index"+                               , "indexOf"+                               , "innerHeight"+                               , "innerWidth"+                               , "input"+                               , "italics"+                               , "javaEnabled"+                               , "join"+                               , "language"+                               , "lastIndex"+                               , "lastIndexOf"+                               , "lastModified"+                               , "lastParen"+                               , "layerX"+                               , "layerY"+                               , "layers"+                               , "left"+                               , "leftContext"+                               , "length"+                               , "link"+                               , "linkColor"+                               , "links"+                               , "load"+                               , "location"+                               , "locationbar"+                               , "lowsrc"+                               , "match"+                               , "menubar"+                               , "method"+                               , "mimeTypes"+                               , "modifiers"+                               , "moveAbove"+                               , "moveBelow"+                               , "moveBy"+                               , "moveTo"+                               , "moveToAbsolute"+                               , "multiline"+                               , "name"+                               , "negative_infinity"+                               , "next"+                               , "open"+                               , "opener"+                               , "options"+                               , "outerHeight"+                               , "outerWidth"+                               , "pageX"+                               , "pageXoffset"+                               , "pageY"+                               , "pageYoffset"+                               , "parent"+                               , "parse"+                               , "pathname"+                               , "personalbar"+                               , "pixelDepth"+                               , "platform"+                               , "plugins"+                               , "pop"+                               , "port"+                               , "positive_infinity"+                               , "preference"+                               , "previous"+                               , "print"+                               , "prompt"+                               , "protocol"+                               , "prototype"+                               , "push"+                               , "referrer"+                               , "refresh"+                               , "releaseEvents"+                               , "reload"+                               , "replace"+                               , "reset"+                               , "resizeBy"+                               , "resizeTo"+                               , "reverse"+                               , "rightContext"+                               , "screenX"+                               , "screenY"+                               , "scroll"+                               , "scrollBy"+                               , "scrollTo"+                               , "scrollbar"+                               , "search"+                               , "select"+                               , "selected"+                               , "selectedIndex"+                               , "self"+                               , "setDate"+                               , "setHours"+                               , "setMinutes"+                               , "setMonth"+                               , "setSeconds"+                               , "setTime"+                               , "setTimeout"+                               , "setUTCDate"+                               , "setUTCDay"+                               , "setUTCFullYear"+                               , "setUTCHours"+                               , "setUTCMilliseconds"+                               , "setUTCMinutes"+                               , "setUTCMonth"+                               , "setUTCSeconds"+                               , "setYear"+                               , "shift"+                               , "siblingAbove"+                               , "siblingBelow"+                               , "small"+                               , "sort"+                               , "source"+                               , "splice"+                               , "split"+                               , "src"+                               , "status"+                               , "statusbar"+                               , "strike"+                               , "sub"+                               , "submit"+                               , "substr"+                               , "substring"+                               , "suffixes"+                               , "sup"+                               , "taintEnabled"+                               , "target"+                               , "test"+                               , "text"+                               , "title"+                               , "toGMTString"+                               , "toLocaleString"+                               , "toLowerCase"+                               , "toSource"+                               , "toString"+                               , "toUTCString"+                               , "toUpperCase"+                               , "toolbar"+                               , "top"+                               , "type"+                               , "unshift"+                               , "unwatch"+                               , "userAgent"+                               , "value"+                               , "valueOf"+                               , "visibility"+                               , "vlinkColor"+                               , "vspace"+                               , "watch"+                               , "which"+                               , "width"+                               , "write"+                               , "writeln"+                               , "x"+                               , "y"+                               , "zIndex"+                               ])+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Float+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Int+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "String 1" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "JSComment" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "Multi/inline Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[=?:]"+                              , reCompiled = Just (compileRegex True "[=?:]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "(Internal regex catch)" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\("+                              , reCompiled = Just (compileRegex True "\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "(Internal regex catch)" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar ":!%&+,-/.*<=>?[]|~^;"+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "-->"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-(-(?!->))+"+                              , reCompiled = Just (compileRegex True "-(-(?!->))+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype"+          , Context+              { cName = "Doctype"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "Doctype Internal Subset" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Internal Subset"+          , Context+              { cName = "Doctype Internal Subset"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<!(ELEMENT|ENTITY|ATTLIST|NOTATION)\\b"+                              , reCompiled =+                                  Just (compileRegex True "<!(ELEMENT|ENTITY|ATTLIST|NOTATION)\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "Doctype Markupdecl" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\?[\\w:_-]*"+                              , reCompiled = Just (compileRegex True "<\\?[\\w:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "PI" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "XUL" , "FindPEntityRefs" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Markupdecl"+          , Context+              { cName = "Doctype Markupdecl"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "Doctype Markupdecl DQ" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "Doctype Markupdecl SQ" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Markupdecl DQ"+          , Context+              { cName = "Doctype Markupdecl DQ"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "XUL" , "FindPEntityRefs" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Doctype Markupdecl SQ"+          , Context+              { cName = "Doctype Markupdecl SQ"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "XUL" , "FindPEntityRefs" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "El Content"+          , Context+              { cName = "El Content"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "</[A-Za-z_:][\\w.:_-]*"+                              , reCompiled = Just (compileRegex True "</[A-Za-z_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "El End" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "XUL" , "FindXML" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "El End"+          , Context+              { cName = "El End"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Element"+          , Context+              { cName = "Element"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "El Content" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Za-z_:][\\w.:_-]*"+                              , reCompiled = Just (compileRegex True "[A-Za-z_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "XUL" , "Attribute" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+[A-Za-z_:][\\w.:_-]*"+                              , reCompiled = Just (compileRegex True "\\s+[A-Za-z_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "Attribute" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindEntityRefs"+          , Context+              { cName = "FindEntityRefs"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "&<"+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindPEntityRefs"+          , Context+              { cName = "FindPEntityRefs"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%[A-Za-z_:][\\w.:_-]*;"+                              , reCompiled = Just (compileRegex True "%[A-Za-z_:][\\w.:_-]*;")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DecValTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "&%"+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindXML"+          , Context+              { cName = "FindXML"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<!--"+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<![CDATA["+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "CDATA" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<!DOCTYPE\\s+"+                              , reCompiled = Just (compileRegex True "<!DOCTYPE\\s+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "Doctype" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<\\?[\\w:_-]*"+                              , reCompiled = Just (compileRegex True "<\\?[\\w:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "PI" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<[A-Za-z_:][\\w.:_-]*"+                              , reCompiled = Just (compileRegex True "<[A-Za-z_:][\\w.:_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "Element" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "XUL" , "FindEntityRefs" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "JSComment"+          , Context+              { cName = "JSComment"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Multi/inline Comment"+          , Context+              { cName = "Multi/inline Comment"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "PI"+          , Context+              { cName = "PI"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '?' '>'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Regular Expression"+          , Context+              { cName = "Regular Expression"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/[ig]{0,2}"+                              , reCompiled = Just (compileRegex True "/[ig]{0,2}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{[\\d, ]+\\}"+                              , reCompiled = Just (compileRegex True "\\{[\\d, ]+\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[bB]"+                              , reCompiled = Just (compileRegex True "\\\\[bB]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[nrtvfDdSsWw]"+                              , reCompiled = Just (compileRegex True "\\\\[nrtvfDdSsWw]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch =+                          [ Push ( "XUL" , "(charclass caret first check)" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$(?=/)"+                              , reCompiled = Just (compileRegex True "\\$(?=/)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = AnyChar "?+*()|"+                      , rAttribute = FloatTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Regular Expression Character Class"+          , Context+              { cName = "Regular Expression Character Class"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[\\[\\]]"+                              , reCompiled = Just (compileRegex True "\\\\[\\[\\]]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = BaseNTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Start"+          , Context+              { cName = "Start"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "XUL" , "FindXML" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = HlCStringChar+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String 1"+          , Context+              { cName = "String 1"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "String" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Value"+          , Context+              { cName = "Value"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "Value DQ" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "XUL" , "Value SQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\S"+                              , reCompiled = Just (compileRegex True "\\S")+                              , reCaseSensitive = True+                              }+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Value DQ"+          , Context+              { cName = "Value DQ"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "XUL" , "FindEntityRefs" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Value SQ"+          , Context+              { cName = "Value SQ"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "XUL" , "FindEntityRefs" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "region_marker"+          , Context+              { cName = "region_marker"+              , cSyntax = "XUL"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = RegionMarkerTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = RegionMarkerTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor =+      "Wilbert Berendsen (wilbert@kde.nl), Anders Lund (anders@alweb.dk), Joseph Wenninger (jowenn@kde.org), Whitehawk Stormchaser (zerokode@gmx.net), Marc Dassonneville (marc.dassonneville@gmail.com)"+  , sVersion = "2"+  , sLicense = "LGPL"+  , sExtensions = [ "*.xul" , "*.xbl" ]+  , sStartingContext = "Start"+  }
+ src/Skylighting/Syntax/Yacc.hs view
@@ -0,0 +1,1020 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Yacc (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex++syntax :: Syntax+syntax = Syntax+  { sName = "Yacc/Bison"+  , sFilename = "yacc.xml"+  , sShortname = "Yacc"+  , sContexts =+      fromList+        [ ( "C Declarations"+          , Context+              { cName = "C Declarations"+              , cSyntax = "Yacc/Bison"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Yacc/Bison" , "Comment" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '%' '}'+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "C++" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Char"+          , Context+              { cName = "Char"+              , cSyntax = "Yacc/Bison"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CharTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "Yacc/Bison"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '/' '*'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Yacc/Bison" , "CommentStar" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '/' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Yacc/Bison" , "CommentSlash" ) ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CommentSlash"+          , Context+              { cName = "CommentSlash"+              , cSyntax = "Yacc/Bison"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^\\\\]$"+                              , reCompiled = Just (compileRegex True "[^\\\\]$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CommentStar"+          , Context+              { cName = "CommentStar"+              , cSyntax = "Yacc/Bison"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '*' '/'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Declarations"+          , Context+              { cName = "Declarations"+              , cSyntax = "Yacc/Bison"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Yacc/Bison" , "Comment" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "%union"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Yacc/Bison" , "Union Start" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '%' '%'+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Yacc/Bison" , "Rules" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '%' '{'+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Yacc/Bison" , "C Declarations" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '%'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Yacc/Bison" , "Percent Command" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Dol"+          , Context+              { cName = "Dol"+              , cSyntax = "Yacc/Bison"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "<[^>]+>"+                              , reCompiled = Just (compileRegex True "<[^>]+>")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Yacc/Bison" , "DolEnd" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Push ( "Yacc/Bison" , "DolEnd" ) ]+              , cDynamic = False+              }+          )+        , ( "DolEnd"+          , Context+              { cName = "DolEnd"+              , cSyntax = "Yacc/Bison"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\d+"+                              , reCompiled = Just (compileRegex True "\\d+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Normal C Bloc"+          , Context+              { cName = "Normal C Bloc"+              , cSyntax = "Yacc/Bison"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Yacc/Bison" , "Normal C Bloc" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "C++" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '$'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Yacc/Bison" , "Dol" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "PC type"+          , Context+              { cName = "PC type"+              , cSyntax = "Yacc/Bison"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '>'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = DataTypeTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Percent Command"+          , Context+              { cName = "Percent Command"+              , cSyntax = "Yacc/Bison"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Yacc/Bison" , "Comment" )+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\W"+                              , reCompiled = Just (compileRegex True "\\W")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Yacc/Bison" , "Percent Command In" ) ]+                      }+                  ]+              , cAttribute = KeywordTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Percent Command In"+          , Context+              { cName = "Percent Command In"+              , cSyntax = "Yacc/Bison"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Yacc/Bison" , "StringOrChar" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '<'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Yacc/Bison" , "PC type" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Pre Start"+          , Context+              { cName = "Pre Start"+              , cSyntax = "Yacc/Bison"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Yacc/Bison" , "Comment" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '%' '{'+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Yacc/Bison" , "C Declarations" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Yacc/Bison" , "Declarations" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Rule In"+          , Context+              { cName = "Rule In"+              , cSyntax = "Yacc/Bison"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Yacc/Bison" , "Comment" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar ';'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Yacc/Bison" , "Normal C Bloc" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '|'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Yacc/Bison" , "StringOrChar" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Rules"+          , Context+              { cName = "Rules"+              , cSyntax = "Yacc/Bison"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Yacc/Bison" , "Comment" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '%' '%'+                      , rAttribute = BaseNTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Yacc/Bison" , "User Code" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Yacc/Bison" , "Rule In" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "String"+          , Context+              { cName = "String"+              , cSyntax = "Yacc/Bison"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\."+                              , reCompiled = Just (compileRegex True "\\\\.")+                              , reCaseSensitive = True+                              }+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "StringOrChar"+          , Context+              { cName = "StringOrChar"+              , cSyntax = "Yacc/Bison"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = CharTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Yacc/Bison" , "Char" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Yacc/Bison" , "String" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Union In"+          , Context+              { cName = "Union In"+              , cSyntax = "Yacc/Bison"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Yacc/Bison" , "Union InIn" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "C++" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Union InIn"+          , Context+              { cName = "Union InIn"+              , cSyntax = "Yacc/Bison"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Yacc/Bison" , "Union InIn" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "C++" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Union Start"+          , Context+              { cName = "Union Start"+              , cSyntax = "Yacc/Bison"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Yacc/Bison" , "Comment" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Yacc/Bison" , "Union In" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AlertTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "User Code"+          , Context+              { cName = "User Code"+              , cSyntax = "Yacc/Bison"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "C++" , "" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Jan Villat (jan.villat@net2000.ch)"+  , sVersion = "3"+  , sLicense = "LGPL"+  , sExtensions = [ "*.y" , "*.yy" ]+  , sStartingContext = "Pre Start"+  }
+ src/Skylighting/Syntax/Yaml.hs view
@@ -0,0 +1,1602 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Yaml (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex++syntax :: Syntax+syntax = Syntax+  { sName = "YAML"+  , sFilename = "yaml.xml"+  , sShortname = "Yaml"+  , sContexts =+      fromList+        [ ( "EOD"+          , Context+              { cName = "EOD"+              , cSyntax = "YAML"+              , cRules = []+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "attribute"+          , Context+              { cName = "attribute"+              , cSyntax = "YAML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "comment" ) ]+                      }+                  ]+              , cAttribute = AttributeTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "attribute-end"+          , Context+              { cName = "attribute-end"+              , cSyntax = "YAML"+              , cRules = []+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "attribute-end-inline"+          , Context+              { cName = "attribute-end-inline"+              , cSyntax = "YAML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s*"+                              , reCompiled = Just (compileRegex True "\\s*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = ",\\s"+                              , reCompiled = Just (compileRegex True ",\\s")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop , Pop , Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "attribute-inline"+          , Context+              { cName = "attribute-inline"+              , cSyntax = "YAML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "comment" ) ]+                      }+                  ]+              , cAttribute = AttributeTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "attribute-pre"+          , Context+              { cName = "attribute-pre"+              , cSyntax = "YAML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "null$"+                              , reCompiled = Just (compileRegex True "null$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "!!\\S+"+                              , reCompiled = Just (compileRegex True "!!\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "list" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "hash" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute-string" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute-stringx" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&\\S+"+                              , reCompiled = Just (compileRegex True "&\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\*\\S+"+                              , reCompiled = Just (compileRegex True "\\*\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute" ) ]+                      }+                  ]+              , cAttribute = AttributeTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "attribute-pre-inline"+          , Context+              { cName = "attribute-pre-inline"+              , cSyntax = "YAML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "null"+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "!!\\S+"+                              , reCompiled = Just (compileRegex True "!!\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "list" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "hash" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute-string-inline" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute-stringx-inline" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&\\S+"+                              , reCompiled = Just (compileRegex True "&\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute-inline" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\*\\S+"+                              , reCompiled = Just (compileRegex True "\\*\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute-inline" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = AttributeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute-inline" ) ]+                      }+                  ]+              , cAttribute = AttributeTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "attribute-string"+          , Context+              { cName = "attribute-string"+              , cSyntax = "YAML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute-end" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "attribute-string-inline"+          , Context+              { cName = "attribute-string-inline"+              , cSyntax = "YAML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute-end-inline" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "attribute-stringx"+          , Context+              { cName = "attribute-stringx"+              , cSyntax = "YAML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute-end" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "attribute-stringx-inline"+          , Context+              { cName = "attribute-stringx-inline"+              , cSyntax = "YAML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute-end-inline" ) ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "comment"+          , Context+              { cName = "comment"+              , cSyntax = "YAML"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Modelines" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "dash"+          , Context+              { cName = "dash"+              , cSyntax = "YAML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "null$"+                              , reCompiled = Just (compileRegex True "null$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "!!\\S+"+                              , reCompiled = Just (compileRegex True "!!\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&\\S+"+                              , reCompiled = Just (compileRegex True "&\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\*\\S+"+                              , reCompiled = Just (compileRegex True "\\*\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "."+                              , reCompiled = Just (compileRegex True ".")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "directive"+          , Context+              { cName = "directive"+              , cSyntax = "YAML"+              , cRules = []+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "hash"+          , Context+              { cName = "hash"+              , cSyntax = "YAML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\??\\s*[^\"'#-][^:#]*:"+                              , reCompiled = Just (compileRegex True "\\??\\s*[^\"'#-][^:#]*:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute-pre-inline" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\??\\s*\"[^\"#]+\"\\s*:"+                              , reCompiled = Just (compileRegex True "\\??\\s*\"[^\"#]+\"\\s*:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute-pre-inline" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\??\\s*'[^'#]+'\\s*:"+                              , reCompiled = Just (compileRegex True "\\??\\s*'[^'#]+'\\s*:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute-pre-inline" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "header"+          , Context+              { cName = "header"+              , cSyntax = "YAML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "comment" ) ]+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "list"+          , Context+              { cName = "list"+              , cSyntax = "YAML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\??\\s*[^\"'#-][^:#]*:"+                              , reCompiled = Just (compileRegex True "\\??\\s*[^\"'#-][^:#]*:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute-pre" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\??\\s*\"[^\"#]+\"\\s*:"+                              , reCompiled = Just (compileRegex True "\\??\\s*\"[^\"#]+\"\\s*:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute-pre" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\??\\s*'[^'#]+'\\s*:"+                              , reCompiled = Just (compileRegex True "\\??\\s*'[^'#]+'\\s*:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute-pre" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "null"+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "!!\\S+"+                              , reCompiled = Just (compileRegex True "!!\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "list" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "hash" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&\\S+"+                              , reCompiled = Just (compileRegex True "&\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\*\\S+"+                              , reCompiled = Just (compileRegex True "\\*\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "string" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "stringx" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ','+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "normal"+          , Context+              { cName = "normal"+              , cSyntax = "YAML"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "---"+                              , reCompiled = Just (compileRegex True "---")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "YAML" , "header" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.\\.\\.$"+                              , reCompiled = Just (compileRegex True "\\.\\.\\.$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "YAML" , "EOD" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%"+                              , reCompiled = Just (compileRegex True "%")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "YAML" , "directive" ) ]+                      }+                  , Rule+                      { rMatcher = DetectSpaces+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "comment" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '-'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "dash" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "list" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '{'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "hash" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "!!\\S+"+                              , reCompiled = Just (compileRegex True "!!\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "&\\S+"+                              , reCompiled = Just (compileRegex True "&\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\*\\S+"+                              , reCompiled = Just (compileRegex True "\\*\\S+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\??\\s*[^\"'#-][^:#]*:"+                              , reCompiled = Just (compileRegex True "\\??\\s*[^\"'#-][^:#]*:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute-pre" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\??\\s*\"[^\"#]+\"\\s*:"+                              , reCompiled = Just (compileRegex True "\\??\\s*\"[^\"#]+\"\\s*:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute-pre" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\??\\s*'[^'#]+'\\s*:"+                              , reCompiled = Just (compileRegex True "\\??\\s*'[^'#]+'\\s*:")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "attribute-pre" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "string" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "YAML" , "stringx" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "string"+          , Context+              { cName = "string"+              , cSyntax = "YAML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "stringx"+          , Context+              { cName = "stringx"+              , cSyntax = "YAML"+              , cRules =+                  [ Rule+                      { rMatcher = DetectIdentifier+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Dr Orlovsky MA (dr.orlovsky@gmail.com)"+  , sVersion = "3"+  , sLicense = "LGPL"+  , sExtensions = [ "*.yaml" , "*.yml" ]+  , sStartingContext = "normal"+  }
+ src/Skylighting/Syntax/Zsh.hs view
@@ -0,0 +1,4297 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Syntax.Zsh (syntax) where++import Skylighting.Types+import Data.Map+import Skylighting.Regex+import qualified Data.Set++syntax :: Syntax+syntax = Syntax+  { sName = "Zsh"+  , sFilename = "zsh.xml"+  , sShortname = "Zsh"+  , sContexts =+      fromList+        [ ( "Assign"+          , Context+              { cName = "Assign"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "AssignArray" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\w:,+_./-]"+                              , reCompiled = Just (compileRegex True "[\\w:,+_./-]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "AssignArray"+          , Context+              { cName = "AssignArray"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "Subscript" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "Assign" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "AssignSubscr"+          , Context+              { cName = "AssignSubscr"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "Subscript" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '+' '='+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "Assign" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "Assign" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "Case"+          , Context+              { cName = "Case"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\sin\\b"+                              , reCompiled = Just (compileRegex True "\\sin\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "CaseIn" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CaseExpr"+          , Context+              { cName = "CaseExpr"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars ';' ';'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "esac(?=$|[\\s;)])"+                              , reCompiled = Just (compileRegex True "esac(?=$|[\\s;)])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindAll" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CaseIn"+          , Context+              { cName = "CaseIn"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\besac(?=$|[\\s;)])"+                              , reCompiled = Just (compileRegex True "\\besac(?=$|[\\s;)])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "CaseExpr" ) ]+                      }+                  , Rule+                      { rMatcher = AnyChar "(|"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Comment"+          , Context+              { cName = "Comment"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CommentBackq"+          , Context+              { cName = "CommentBackq"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^`](?=`)"+                              , reCompiled = Just (compileRegex True "[^`](?=`)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "CommentParen"+          , Context+              { cName = "CommentParen"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^)](?=\\))"+                              , reCompiled = Just (compileRegex True "[^)](?=\\))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Alerts" , "" )+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = CommentTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ExprBracket"+          , Context+              { cName = "ExprBracket"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s\\](?=($|[\\s;|&]))"+                              , reCompiled = Just (compileRegex True "\\s\\](?=($|[\\s;|&]))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\](?=($|[\\s;|&]))"+                              , reCompiled = Just (compileRegex True "\\](?=($|[\\s;|&]))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "ExprSubParen" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindTests" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ExprDblBracket"+          , Context+              { cName = "ExprDblBracket"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s\\]\\](?=($|[\\s;|&]))"+                              , reCompiled = Just (compileRegex True "\\s\\]\\](?=($|[\\s;|&]))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\]\\](?=($|[\\s;|&]))"+                              , reCompiled = Just (compileRegex True "\\]\\](?=($|[\\s;|&]))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "ExprSubParen" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindTests" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ExprDblParen"+          , Context+              { cName = "ExprDblParen"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars ')' ')'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "ExprSubParen" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ExprDblParenSubst"+          , Context+              { cName = "ExprDblParenSubst"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars ')' ')'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "ExprSubParen" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ExprSubParen"+          , Context+              { cName = "ExprSubParen"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "ExprSubParen" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindAll"+          , Context+              { cName = "FindAll"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindComments" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindCommands" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindCommands"+          , Context+              { cName = "FindCommands"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '(' '('+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "ExprDblParen" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[\\[(?=($|\\s))"+                              , reCompiled = Just (compileRegex True "\\[\\[(?=($|\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Zsh" , "ExprDblBracket" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s\\[\\[(?=($|\\s))"+                              , reCompiled = Just (compileRegex True "\\s\\[\\[(?=($|\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "ExprDblBracket" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\[(?=($|\\s))"+                              , reCompiled = Just (compileRegex True "\\[(?=($|\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Push ( "Zsh" , "ExprBracket" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s\\[(?=($|\\s))"+                              , reCompiled = Just (compileRegex True "\\s\\[(?=($|\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "ExprBracket" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{(?=($|\\s))"+                              , reCompiled = Just (compileRegex True "\\{(?=($|\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "Group" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '('+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "SubShell" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bdo(?![\\w$+-])"+                              , reCompiled = Just (compileRegex True "\\bdo(?![\\w$+-])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bdone(?![\\w$+-])"+                              , reCompiled = Just (compileRegex True "\\bdone(?![\\w$+-])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bif(?=($|\\s))"+                              , reCompiled = Just (compileRegex True "\\bif(?=($|\\s))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bfi(?![\\w$+-])"+                              , reCompiled = Just (compileRegex True "\\bfi(?![\\w$+-])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bcase(?![\\w$+-])"+                              , reCompiled = Just (compileRegex True "\\bcase(?![\\w$+-])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "Case" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-[A-Za-z0-9][A-Za-z0-9_]*"+                              , reCompiled = Just (compileRegex True "-[A-Za-z0-9][A-Za-z0-9_]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "--[a-z][A-Za-z0-9_-]*"+                              , reCompiled = Just (compileRegex True "--[a-z][A-Za-z0-9_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[A-Za-z_][A-Za-z0-9_]*\\+?="+                              , reCompiled =+                                  Just (compileRegex True "\\b[A-Za-z_][A-Za-z0-9_]*\\+?=")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "Assign" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[A-Za-z_][A-Za-z0-9_]*(?=\\[.+\\]\\+?=)"+                              , reCompiled =+                                  Just+                                    (compileRegex True "\\b[A-Za-z_][A-Za-z0-9_]*(?=\\[.+\\]\\+?=)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "AssignSubscr" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect ":()"+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\bfunction\\b"+                              , reCompiled = Just (compileRegex True "\\bfunction\\b")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "FunctionDef" ) ]+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,;<=>?\\`|~"+                              }+                            (makeWordSet+                               True+                               [ "elif"+                               , "else"+                               , "for"+                               , "function"+                               , "in"+                               , "select"+                               , "set"+                               , "then"+                               , "until"+                               , "while"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\.(?=\\s)"+                              , reCompiled = Just (compileRegex True "\\.(?=\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,;<=>?\\`|~"+                              }+                            (makeWordSet+                               True+                               [ "-"+                               , "."+                               , ":"+                               , "alias"+                               , "autoload"+                               , "bg"+                               , "bindkey"+                               , "break"+                               , "builtin"+                               , "bye"+                               , "cap"+                               , "cd"+                               , "chdir"+                               , "clone"+                               , "command"+                               , "comparguments"+                               , "compcall"+                               , "compctl"+                               , "compdescribe"+                               , "compfiles"+                               , "compgroups"+                               , "compquote"+                               , "comptags"+                               , "comptry"+                               , "compvalues"+                               , "continue"+                               , "dirs"+                               , "disable"+                               , "disown"+                               , "echo"+                               , "echotc"+                               , "echoti"+                               , "emulate"+                               , "enable"+                               , "eval"+                               , "exec"+                               , "exit"+                               , "false"+                               , "fc"+                               , "fg"+                               , "functions"+                               , "getcap"+                               , "getopts"+                               , "hash"+                               , "history"+                               , "jobs"+                               , "kill"+                               , "let"+                               , "limit"+                               , "log"+                               , "logout"+                               , "noglob"+                               , "popd"+                               , "print"+                               , "printf"+                               , "pushd"+                               , "pushln"+                               , "pwd"+                               , "r"+                               , "rehash"+                               , "return"+                               , "sched"+                               , "set"+                               , "setcap"+                               , "setopt"+                               , "shift"+                               , "source"+                               , "stat"+                               , "suspend"+                               , "test"+                               , "times"+                               , "trap"+                               , "true"+                               , "ttyctl"+                               , "type"+                               , "ulimit"+                               , "umask"+                               , "unalias"+                               , "unfunction"+                               , "unhash"+                               , "unlimit"+                               , "unset"+                               , "unsetopt"+                               , "vared"+                               , "wait"+                               , "whence"+                               , "where"+                               , "which"+                               , "zcompile"+                               , "zformat"+                               , "zftp"+                               , "zle"+                               , "zmodload"+                               , "zparseopts"+                               , "zprof"+                               , "zpty"+                               , "zregexparse"+                               , "zsocket"+                               , "zstyle"+                               , "ztcp"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,;<=>?\\`|~"+                              }+                            (makeWordSet+                               True+                               [ "aclocal"+                               , "aconnect"+                               , "aplay"+                               , "apm"+                               , "apmsleep"+                               , "apropos"+                               , "ar"+                               , "arch"+                               , "arecord"+                               , "as"+                               , "as86"+                               , "autoconf"+                               , "autoheader"+                               , "automake"+                               , "awk"+                               , "basename"+                               , "bash"+                               , "bc"+                               , "bison"+                               , "bunzip2"+                               , "bzcat"+                               , "bzcmp"+                               , "bzdiff"+                               , "bzegrep"+                               , "bzfgrep"+                               , "bzgrep"+                               , "bzip2"+                               , "bzip2recover"+                               , "bzless"+                               , "bzmore"+                               , "c++"+                               , "cal"+                               , "cat"+                               , "cc"+                               , "cd-read"+                               , "cdda2wav"+                               , "cdparanoia"+                               , "cdrdao"+                               , "cdrecord"+                               , "chattr"+                               , "chfn"+                               , "chgrp"+                               , "chmod"+                               , "chown"+                               , "chroot"+                               , "chsh"+                               , "chvt"+                               , "clear"+                               , "cmp"+                               , "co"+                               , "col"+                               , "comm"+                               , "cp"+                               , "cpio"+                               , "cpp"+                               , "cut"+                               , "date"+                               , "dc"+                               , "dcop"+                               , "dd"+                               , "deallocvt"+                               , "df"+                               , "diff"+                               , "diff3"+                               , "dir"+                               , "dircolors"+                               , "directomatic"+                               , "dirname"+                               , "dmesg"+                               , "dnsdomainname"+                               , "domainname"+                               , "du"+                               , "dumpkeys"+                               , "echo"+                               , "ed"+                               , "egrep"+                               , "env"+                               , "expr"+                               , "false"+                               , "fbset"+                               , "fgconsole"+                               , "fgrep"+                               , "file"+                               , "find"+                               , "flex"+                               , "flex++"+                               , "fmt"+                               , "free"+                               , "ftp"+                               , "funzip"+                               , "fuser"+                               , "g++"+                               , "gawk"+                               , "gc"+                               , "gcc"+                               , "gdb"+                               , "getent"+                               , "getkeycodes"+                               , "getopt"+                               , "gettext"+                               , "gettextize"+                               , "gimp"+                               , "gimp-remote"+                               , "gimptool"+                               , "gmake"+                               , "gocr"+                               , "grep"+                               , "groff"+                               , "groups"+                               , "gs"+                               , "gunzip"+                               , "gzexe"+                               , "gzip"+                               , "head"+                               , "hexdump"+                               , "hostname"+                               , "id"+                               , "igawk"+                               , "install"+                               , "join"+                               , "kbd_mode"+                               , "kbdrate"+                               , "kdialog"+                               , "kfile"+                               , "kill"+                               , "killall"+                               , "last"+                               , "lastb"+                               , "ld"+                               , "ld86"+                               , "ldd"+                               , "less"+                               , "lex"+                               , "link"+                               , "ln"+                               , "loadkeys"+                               , "loadunimap"+                               , "locate"+                               , "lockfile"+                               , "login"+                               , "logname"+                               , "lp"+                               , "lpr"+                               , "ls"+                               , "lsattr"+                               , "lsmod"+                               , "lsmod.old"+                               , "lynx"+                               , "lzcat"+                               , "lzcmp"+                               , "lzdiff"+                               , "lzegrep"+                               , "lzfgrep"+                               , "lzgrep"+                               , "lzless"+                               , "lzma"+                               , "lzmainfo"+                               , "lzmore"+                               , "m4"+                               , "make"+                               , "man"+                               , "mapscrn"+                               , "mesg"+                               , "mkdir"+                               , "mkfifo"+                               , "mknod"+                               , "mktemp"+                               , "more"+                               , "mount"+                               , "msgfmt"+                               , "mv"+                               , "namei"+                               , "nano"+                               , "nasm"+                               , "nawk"+                               , "netstat"+                               , "nice"+                               , "nisdomainname"+                               , "nl"+                               , "nm"+                               , "nm86"+                               , "nmap"+                               , "nohup"+                               , "nop"+                               , "nroff"+                               , "od"+                               , "openvt"+                               , "passwd"+                               , "patch"+                               , "pcregrep"+                               , "pcretest"+                               , "perl"+                               , "perror"+                               , "pgawk"+                               , "pidof"+                               , "ping"+                               , "pr"+                               , "printf"+                               , "procmail"+                               , "prune"+                               , "ps"+                               , "ps2ascii"+                               , "ps2epsi"+                               , "ps2frag"+                               , "ps2pdf"+                               , "ps2ps"+                               , "psbook"+                               , "psmerge"+                               , "psnup"+                               , "psresize"+                               , "psselect"+                               , "pstops"+                               , "pstree"+                               , "pwd"+                               , "rbash"+                               , "rcs"+                               , "readlink"+                               , "red"+                               , "resizecons"+                               , "rev"+                               , "rm"+                               , "rmdir"+                               , "run-parts"+                               , "sash"+                               , "scp"+                               , "sed"+                               , "seq"+                               , "setfont"+                               , "setkeycodes"+                               , "setleds"+                               , "setmetamode"+                               , "setserial"+                               , "setterm"+                               , "sh"+                               , "showkey"+                               , "shred"+                               , "size"+                               , "size86"+                               , "skill"+                               , "sleep"+                               , "slogin"+                               , "snice"+                               , "sort"+                               , "sox"+                               , "split"+                               , "ssed"+                               , "ssh"+                               , "ssh-add"+                               , "ssh-agent"+                               , "ssh-keygen"+                               , "ssh-keyscan"+                               , "stat"+                               , "strings"+                               , "strip"+                               , "stty"+                               , "su"+                               , "sudo"+                               , "suidperl"+                               , "sum"+                               , "sync"+                               , "tac"+                               , "tail"+                               , "tar"+                               , "tee"+                               , "tempfile"+                               , "test"+                               , "touch"+                               , "tr"+                               , "troff"+                               , "true"+                               , "umount"+                               , "uname"+                               , "unicode_start"+                               , "unicode_stop"+                               , "uniq"+                               , "unlink"+                               , "unlzma"+                               , "unxz"+                               , "unzip"+                               , "updatedb"+                               , "updmap"+                               , "uptime"+                               , "users"+                               , "utmpdump"+                               , "uuidgen"+                               , "vdir"+                               , "vmstat"+                               , "w"+                               , "wall"+                               , "wc"+                               , "wget"+                               , "whatis"+                               , "whereis"+                               , "which"+                               , "who"+                               , "whoami"+                               , "write"+                               , "xargs"+                               , "xhost"+                               , "xmodmap"+                               , "xset"+                               , "xz"+                               , "xzcat"+                               , "yacc"+                               , "yes"+                               , "ypdomainname"+                               , "zcat"+                               , "zcmp"+                               , "zdiff"+                               , "zegrep"+                               , "zfgrep"+                               , "zforce"+                               , "zgrep"+                               , "zip"+                               , "zless"+                               , "zmore"+                               , "znew"+                               , "zsh"+                               , "zsoelim"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          Keyword+                            KeywordAttr+                              { keywordCaseSensitive = True+                              , keywordDelims = Data.Set.fromList "\t\n !&()*+,;<=>?\\`|~"+                              }+                            (makeWordSet+                               True+                               [ "declare"+                               , "export"+                               , "float"+                               , "getln"+                               , "integer"+                               , "local"+                               , "read"+                               , "readonly"+                               , "typeset"+                               , "unset"+                               ])+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "VarName" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\d*<<<"+                              , reCompiled = Just (compileRegex True "\\d*<<<")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = StringDetect "<<"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "HereDoc" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[<>]\\("+                              , reCompiled = Just (compileRegex True "[<>]\\(")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "ProcessSubst" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([0-9]*(>{1,2}|<)(&[0-9]+-?)?|&>|>&|[0-9]*<>)"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "([0-9]*(>{1,2}|<)(&[0-9]+-?)?|&>|>&|[0-9]*<>)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([|&])\\1?"+                              , reCompiled = Just (compileRegex True "([|&])\\1?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Za-z_:][A-Za-z0-9_:#%@-]*\\s*\\(\\)"+                              , reCompiled =+                                  Just (compileRegex True "[A-Za-z_:][A-Za-z0-9_:#%@-]*\\s*\\(\\)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindComments"+          , Context+              { cName = "FindComments"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "Comment" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\s;](?=#)"+                              , reCompiled = Just (compileRegex True "[\\s;](?=#)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "Comment" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindCommentsBackq"+          , Context+              { cName = "FindCommentsBackq"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "CommentBackq" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\s;](?=#)"+                              , reCompiled = Just (compileRegex True "[\\s;](?=#)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "CommentBackq" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindCommentsParen"+          , Context+              { cName = "FindCommentsParen"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '#'+                      , rAttribute = CommentTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = True+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "CommentParen" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[\\s;](?=#)"+                              , reCompiled = Just (compileRegex True "[\\s;](?=#)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "CommentParen" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindMost"+          , Context+              { cName = "FindMost"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindComments" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindOthers"+          , Context+              { cName = "FindOthers"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[][;\\\\$`{}()|&<>* ]"+                              , reCompiled = Just (compileRegex True "\\\\[][;\\\\$`{}()|&<>* ]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\$"+                              , reCompiled = Just (compileRegex True "\\\\$")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\{(?!(\\s|$))\\S*\\}"+                              , reCompiled = Just (compileRegex True "\\{(?!(\\s|$))\\S*\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([\\w_@.%*?+-]|\\\\ )*(?=/)"+                              , reCompiled =+                                  Just (compileRegex True "([\\w_@.%*?+-]|\\\\ )*(?=/)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "~\\w*"+                              , reCompiled = Just (compileRegex True "~\\w*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "/([\\w_@.%*?+-]|\\\\ )*(?=([\\s/):;$`'\"]|$))"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "/([\\w_@.%*?+-]|\\\\ )*(?=([\\s/):;$`'\"]|$))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindStrings"+          , Context+              { cName = "FindStrings"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = Detect2Chars '\\' '\''+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = Detect2Chars '\\' '"'+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "StringSQ" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "StringDQ" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "StringEsc" ) ]+                      }+                  , Rule+                      { rMatcher = Detect2Chars '$' '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "StringDQ" ) ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindSubstitutions"+          , Context+              { cName = "FindSubstitutions"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[A-Za-z_][A-Za-z0-9_]*\\["+                              , reCompiled =+                                  Just (compileRegex True "\\$[A-Za-z_][A-Za-z0-9_]*\\[")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "Subscript" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[A-Za-z_][A-Za-z0-9_]*"+                              , reCompiled = Just (compileRegex True "\\$[A-Za-z_][A-Za-z0-9_]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$[*@#?$!_0-9-]"+                              , reCompiled = Just (compileRegex True "\\$[*@#?$!_0-9-]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\{[*@#?$!_0-9-]\\}"+                              , reCompiled = Just (compileRegex True "\\$\\{[*@#?$!_0-9-]\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\{#[A-Za-z_][A-Za-z0-9_]*(\\[[*@]\\])?\\}"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\$\\{#[A-Za-z_][A-Za-z0-9_]*(\\[[*@]\\])?\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\{![A-Za-z_][A-Za-z0-9_]*(\\[[*@]\\]|[*@])?\\}"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\$\\{![A-Za-z_][A-Za-z0-9_]*(\\[[*@]\\]|[*@])?\\}")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\{[A-Za-z_][A-Za-z0-9_]*"+                              , reCompiled =+                                  Just (compileRegex True "\\$\\{[A-Za-z_][A-Za-z0-9_]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "VarBrace" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\$\\{[*@#?$!_0-9-](?=[:#%/=?+-])"+                              , reCompiled =+                                  Just (compileRegex True "\\$\\{[*@#?$!_0-9-](?=[:#%/=?+-])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "VarBrace" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "$(("+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "ExprDblParenSubst" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "$(<"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "SubstFile" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "$("+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "SubstCommand" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "SubstBackq" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[`$\\\\]"+                              , reCompiled = Just (compileRegex True "\\\\[`$\\\\]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FindTests"+          , Context+              { cName = "FindTests"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-[abcdefghkprstuwxOGLSNozn](?=\\s)"+                              , reCompiled =+                                  Just (compileRegex True "-[abcdefghkprstuwxOGLSNozn](?=\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-([no]t|ef)(?=\\s)"+                              , reCompiled = Just (compileRegex True "-([no]t|ef)(?=\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "([!=]=?|[><])(?=\\s)"+                              , reCompiled = Just (compileRegex True "([!=]=?|[><])(?=\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-(eq|ne|[gl][te])(?=\\s)"+                              , reCompiled = Just (compileRegex True "-(eq|ne|[gl][te])(?=\\s)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "FunctionDef"+          , Context+              { cName = "FunctionDef"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\s+[A-Za-z_:][A-Za-z0-9_:#%@-]*(\\s*\\(\\))?"+                              , reCompiled =+                                  Just+                                    (compileRegex+                                       True "\\s+[A-Za-z_:][A-Za-z0-9_:#%@-]*(\\s*\\(\\))?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = FunctionTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = FunctionTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "Group"+          , Context+              { cName = "Group"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindAll" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "HereDoc"+          , Context+              { cName = "HereDoc"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<-\\s*\"([^|&;()<>\\s]+)\")"+                              , reCompiled =+                                  Just (compileRegex True "(<<-\\s*\"([^|&;()<>\\s]+)\")")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "HereDocIQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<-\\s*'([^|&;()<>\\s]+)')"+                              , reCompiled =+                                  Just (compileRegex True "(<<-\\s*'([^|&;()<>\\s]+)')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "HereDocIQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<-\\s*\\\\([^|&;()<>\\s]+))"+                              , reCompiled =+                                  Just (compileRegex True "(<<-\\s*\\\\([^|&;()<>\\s]+))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "HereDocIQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<-\\s*([^|&;()<>\\s]+))"+                              , reCompiled = Just (compileRegex True "(<<-\\s*([^|&;()<>\\s]+))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "HereDocINQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<\\s*\"([^|&;()<>\\s]+)\")"+                              , reCompiled =+                                  Just (compileRegex True "(<<\\s*\"([^|&;()<>\\s]+)\")")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "HereDocQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<\\s*'([^|&;()<>\\s]+)')"+                              , reCompiled =+                                  Just (compileRegex True "(<<\\s*'([^|&;()<>\\s]+)')")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "HereDocQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<\\s*\\\\([^|&;()<>\\s]+))"+                              , reCompiled =+                                  Just (compileRegex True "(<<\\s*\\\\([^|&;()<>\\s]+))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "HereDocQ" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(<<\\s*([^|&;()<>\\s]+))"+                              , reCompiled = Just (compileRegex True "(<<\\s*([^|&;()<>\\s]+))")+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = True+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "HereDocNQ" ) ]+                      }+                  , Rule+                      { rMatcher = StringDetect "<<"+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "HereDocINQ"+          , Context+              { cName = "HereDocINQ"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1" , reCompiled = Nothing , reCaseSensitive = True }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "HereDocRemainder" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\t*%2\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "HereDocIQ"+          , Context+              { cName = "HereDocIQ"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1" , reCompiled = Nothing , reCaseSensitive = True }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "HereDocRemainder" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\t*%2\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "HereDocNQ"+          , Context+              { cName = "HereDocNQ"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1" , reCompiled = Nothing , reCaseSensitive = True }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "HereDocRemainder" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%2\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "HereDocQ"+          , Context+              { cName = "HereDocQ"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%1" , reCompiled = Nothing , reCaseSensitive = True }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "HereDocRemainder" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "%2\\b"+                              , reCompiled = Nothing+                              , reCaseSensitive = True+                              }+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = True+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Just 0+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = True+              }+          )+        , ( "HereDocRemainder"+          , Context+              { cName = "HereDocRemainder"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindAll" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "ProcessSubst"+          , Context+              { cName = "ProcessSubst"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindCommentsParen" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindCommands" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Start"+          , Context+              { cName = "Start"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindAll" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "StringDQ"+          , Context+              { cName = "StringDQ"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '"'+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[`\"\\\\$\\n]"+                              , reCompiled = Just (compileRegex True "\\\\[`\"\\\\$\\n]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindSubstitutions" )+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "StringEsc"+          , Context+              { cName = "StringEsc"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\[abefnrtv\\\\']"+                              , reCompiled = Just (compileRegex True "\\\\[abefnrtv\\\\']")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\\\([0-7]{1,3}|x[A-Fa-f0-9]{1,2}|c.)"+                              , reCompiled =+                                  Just (compileRegex True "\\\\([0-7]{1,3}|x[A-Fa-f0-9]{1,2}|c.)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = DataTypeTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "StringSQ"+          , Context+              { cName = "StringSQ"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '\''+                      , rAttribute = StringTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  ]+              , cAttribute = StringTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SubShell"+          , Context+              { cName = "SubShell"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindAll" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "Subscript"+          , Context+              { cName = "Subscript"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ']'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindStrings" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindSubstitutions" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindOthers" )+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = OtherTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SubstBackq"+          , Context+              { cName = "SubstBackq"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '`'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindCommentsBackq" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindCommands" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SubstCommand"+          , Context+              { cName = "SubstCommand"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindCommentsParen" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindCommands" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "SubstFile"+          , Context+              { cName = "SubstFile"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ')'+                      , rAttribute = KeywordTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindCommentsParen" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindOthers" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "VarAlt"+          , Context+              { cName = "VarAlt"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "VarBrace"+          , Context+              { cName = "VarBrace"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "Subscript" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "(:?[-=?+]|##?|%%?)"+                              , reCompiled = Just (compileRegex True "(:?[-=?+]|##?|%%?)")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "VarAlt" ) ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "//?"+                              , reCompiled = Just (compileRegex True "//?")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "VarSubst" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "VarSub" ) ]+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "VarName"+          , Context+              { cName = "VarName"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "-[A-Za-z0-9]+"+                              , reCompiled = Just (compileRegex True "-[A-Za-z0-9]+")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "--[a-z][A-Za-z0-9_-]*"+                              , reCompiled = Just (compileRegex True "--[a-z][A-Za-z0-9_-]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "\\b[A-Za-z_][A-Za-z0-9_]*"+                              , reCompiled = Just (compileRegex True "\\b[A-Za-z_][A-Za-z0-9_]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = DetectChar '['+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "Subscript" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '='+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "Assign" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindMost" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[^]})|;`&><]"+                              , reCompiled = Just (compileRegex True "[^]})|;`&><]")+                              , reCaseSensitive = True+                              }+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = [ Pop ]+              , cLineBeginContext = []+              , cFallthrough = True+              , cFallthroughContext = [ Pop ]+              , cDynamic = False+              }+          )+        , ( "VarSub"+          , Context+              { cName = "VarSub"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar ':'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "VarSub2" ) ]+                      }+                  , Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Za-z_][A-Za-z0-9_]*"+                              , reCompiled = Just (compileRegex True "[A-Za-z_][A-Za-z0-9_]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[0-9]+(?=[:}])"+                              , reCompiled = Just (compileRegex True "[0-9]+(?=[:}])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindSubstitutions" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "VarSub2"+          , Context+              { cName = "VarSub2"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[A-Za-z_][A-Za-z0-9_]*"+                              , reCompiled = Just (compileRegex True "[A-Za-z_][A-Za-z0-9_]*")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher =+                          RegExpr+                            RE+                              { reString = "[0-9](?=[:}])"+                              , reCompiled = Just (compileRegex True "[0-9](?=[:}])")+                              , reCaseSensitive = True+                              }+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindSubstitutions" )+                      , rAttribute = ErrorTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = ErrorTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "VarSubst"+          , Context+              { cName = "VarSubst"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = DetectChar '/'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Push ( "Zsh" , "VarSubst2" ) ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        , ( "VarSubst2"+          , Context+              { cName = "VarSubst2"+              , cSyntax = "Zsh"+              , cRules =+                  [ Rule+                      { rMatcher = DetectChar '}'+                      , rAttribute = OtherTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = [ Pop , Pop , Pop ]+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindStrings" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  , Rule+                      { rMatcher = IncludeRules ( "Zsh" , "FindSubstitutions" )+                      , rAttribute = NormalTok+                      , rIncludeAttribute = False+                      , rDynamic = False+                      , rCaseSensitive = True+                      , rChildren = []+                      , rLookahead = False+                      , rFirstNonspace = False+                      , rColumn = Nothing+                      , rContextSwitch = []+                      }+                  ]+              , cAttribute = NormalTok+              , cLineEmptyContext = []+              , cLineEndContext = []+              , cLineBeginContext = []+              , cFallthrough = False+              , cFallthroughContext = []+              , cDynamic = False+              }+          )+        ]+  , sAuthor = "Jonathan Kolberg (bulldog98@kubuntu-de.org)"+  , sVersion = "1"+  , sLicense = "LGPL"+  , sExtensions =+      [ "*.sh"+      , "*.zsh"+      , ".zshrc"+      , ".zprofile"+      , ".zlogin"+      , ".zlogout"+      , ".profile"+      ]+  , sStartingContext = "Start"+  }
+ src/Skylighting/Tokenizer.hs view
@@ -0,0 +1,506 @@+{-# LANGUAGE OverloadedStrings #-}+module Skylighting.Tokenizer (+    tokenize+  , TokenizerConfig(..)+  ) where++import Control.Applicative+import Control.Monad.Except+import Control.Monad.Reader+import Control.Monad.State+import qualified Data.ByteString.Char8 as BS+import Data.CaseInsensitive (mk)+import Data.Char (isAlphaNum, isLetter, isSpace, ord)+import qualified Data.Map as Map+import Data.Maybe (catMaybes, fromMaybe)+import Data.Monoid+import qualified Data.Set as Set+import Data.Text (Text)+import qualified Data.Text as Text+import Data.Text.Encoding (decodeUtf8', encodeUtf8)+import Debug.Trace+import Skylighting.Regex+import Skylighting.Types++info :: String -> TokenizerM ()+info s = do+  tr <- asks traceOutput+  when tr $ trace s (return ())++infoContextStack :: TokenizerM ()+infoContextStack = do+  tr <- asks traceOutput+  when tr $ do+    ContextStack stack <- gets contextStack+    info $ "CONTEXT STACK " ++ show (map cName stack)++newtype ContextStack = ContextStack{ unContextStack :: [Context] }+  deriving (Show)++data TokenizerState = TokenizerState{+    input               :: Text+  , prevChar            :: Char+  , contextStack        :: ContextStack+  , captures            :: [Text]+  , column              :: Int+  , lineContinuation    :: Bool+  , firstNonspaceColumn :: Maybe Int+} deriving (Show)++-- | Configuration options for 'tokenize'.+data TokenizerConfig = TokenizerConfig{+    syntaxMap   :: SyntaxMap  -- ^ Syntax map to use+  , traceOutput :: Bool       -- ^ Generate trace output for debugging+} deriving (Show)++type TokenizerM =+  ExceptT String (ReaderT TokenizerConfig (State TokenizerState))++popContextStack :: TokenizerM ()+popContextStack = do+  ContextStack cs <- gets contextStack+  case cs of+       []     -> throwError "Empty context stack" -- programming error+       (_:[]) -> return ()  -- don't pop last context+       (_:rest) -> do+         modify (\st -> st{ contextStack = ContextStack rest })+         infoContextStack++pushContextStack :: Context -> TokenizerM ()+pushContextStack cont = do+  modify (\st -> st{ contextStack =+                      ContextStack (cont : unContextStack (contextStack st)) } )+  infoContextStack++currentContext :: TokenizerM Context+currentContext = do+  ContextStack cs <- gets contextStack+  case cs of+       []    -> throwError "Empty context stack" -- programming error+       (c:_) -> return c++doContextSwitch :: [ContextSwitch] -> TokenizerM ()+doContextSwitch [] = return ()+doContextSwitch (Pop : xs) = do+  popContextStack+  currentContext >>= checkLineEnd+  doContextSwitch xs+doContextSwitch (Push (syn,c) : xs) = do+  syntaxes <- asks syntaxMap+  case Map.lookup syn syntaxes >>= lookupContext c of+       Just con -> do+         pushContextStack con+         checkLineEnd con+         doContextSwitch xs+       Nothing  -> throwError $ "Unknown syntax or context: " ++ show (syn, c)++lookupContext :: Text -> Syntax -> Maybe Context+lookupContext name syntax | Text.null name =+  if Text.null (sStartingContext syntax)+     then Nothing+     else lookupContext (sStartingContext syntax) syntax+lookupContext name syntax = Map.lookup name $ sContexts syntax++-- | Tokenize some text using 'Syntax'.+tokenize :: TokenizerConfig -> Syntax -> Text -> Either String [SourceLine]+tokenize config syntax inp =+  evalState+    (runReaderT+      (runExceptT (mapM tokenizeLine $ zip (Text.lines inp) [1..])) config)+    startingState{ input = inp+                 , contextStack = case lookupContext+                                       (sStartingContext syntax) syntax of+                                       Just c  -> ContextStack [c]+                                       Nothing -> ContextStack [] }++startingState :: TokenizerState+startingState =+  TokenizerState{ input = Text.empty+                , prevChar = '\n'+                , contextStack = ContextStack []+                , captures = []+                , column = 0+                , lineContinuation = False+                , firstNonspaceColumn = Nothing+                }++tokenizeLine :: (Text, Int) -> TokenizerM [Token]+tokenizeLine (ln, linenum) = do+  cur <- currentContext+  lineCont <- gets lineContinuation+  if lineCont+     then modify $ \st -> st{ lineContinuation = False }+     else do+       modify $ \st -> st{ column = 0+                         , firstNonspaceColumn =+                              Text.findIndex (not . isSpace) ln }+       doContextSwitch (cLineBeginContext cur)+  if Text.null ln+     then doContextSwitch (cLineEmptyContext cur)+     else doContextSwitch (cLineBeginContext cur)+  modify $ \st -> st{ input = ln, prevChar = '\n' }+  ts <- normalizeHighlighting . catMaybes <$> many getToken+  currentContext >>= checkLineEnd+  -- fail if we haven't consumed whole line+  inp <- gets input+  if not (Text.null inp)+     then do+       col <- gets column+       throwError $ "Could not match anything at line " +++         show linenum ++ " column " ++ show col+     else return ts++getToken :: TokenizerM (Maybe Token)+getToken = do+  inp <- gets input+  guard $ not (Text.null inp)+  context <- currentContext+  msum (map tryRule (cRules context)) <|>+     if cFallthrough context+        then doContextSwitch (cFallthroughContext context) >> getToken+        else (\x -> Just (cAttribute context, x)) <$> normalChunk++takeChars :: Int -> TokenizerM Text+takeChars 0 = mzero+takeChars numchars = do+  inp <- gets input+  let t = Text.take numchars inp+  let rest = Text.drop numchars inp+  modify $ \st -> st{ input = rest,+                      prevChar = Text.last t,+                      column = column st + numchars }+  return t++tryRule :: Rule -> TokenizerM (Maybe Token)+tryRule rule = do+  case rColumn rule of+       Nothing -> return ()+       Just n  -> do+         col <- gets column+         guard (col == n)++  when (rFirstNonspace rule) $ do+    firstNonspace <- gets firstNonspaceColumn+    col <- gets column+    guard (firstNonspace == Just col)++  oldstate <- get -- needed for lookahead rules++  let attr = rAttribute rule+  mbtok <- case rMatcher rule of+                DetectChar c -> withAttr attr $ detectChar (rDynamic rule) c+                Detect2Chars c d -> withAttr attr $+                                      detect2Chars (rDynamic rule) c d+                AnyChar cs -> withAttr attr $ anyChar cs+                RangeDetect c d -> withAttr attr $ rangeDetect c d+                RegExpr re -> withAttr attr $ regExpr (rDynamic rule) re+                Int -> withAttr attr $ regExpr False integerRegex+                HlCOct -> withAttr attr $ regExpr False octRegex+                HlCHex -> withAttr attr $ regExpr False hexRegex+                HlCStringChar -> withAttr attr $+                                     regExpr False hlCStringCharRegex+                HlCChar -> withAttr attr $ regExpr False hlCCharRegex+                Float -> withAttr attr $ regExpr False floatRegex+                Keyword kwattr kws ->+                  withAttr attr $ keyword kwattr kws+                StringDetect s -> withAttr attr $+                                    stringDetect (rCaseSensitive rule) s+                WordDetect s -> withAttr attr $+                                    wordDetect (rCaseSensitive rule) s+                LineContinue -> withAttr attr $ lineContinue+                DetectSpaces -> withAttr attr $ detectSpaces+                DetectIdentifier -> withAttr attr $ detectIdentifier+                IncludeRules cname -> includeRules+                   (if rIncludeAttribute rule then Just attr else Nothing)+                   cname+  mbchildren <- msum (map tryRule (rChildren rule))+                 <|> return Nothing++  mbtok' <- case mbtok of+                 Nothing -> return Nothing+                 Just (tt, s)+                   | rLookahead rule -> do+                     modify $ \st -> st{ input = input oldstate+                                       , prevChar = prevChar oldstate+                                       , column = column oldstate }+                     return Nothing+                   | otherwise -> do+                     case mbchildren of+                          Nothing -> return $ Just (tt, s)+                          Just (_, cresult) -> return $ Just (tt, s <> cresult)++  info $ takeWhile (/=' ') (show (rMatcher rule)) ++ " MATCHED " ++ show mbtok'+  doContextSwitch (rContextSwitch rule)+  return mbtok'++withAttr :: TokenType -> TokenizerM Text -> TokenizerM (Maybe Token)+withAttr tt p = do+  res <- p+  case res of+       "" -> return Nothing+       xs -> return $ Just (tt, xs)++hlCStringCharRegex :: RE+hlCStringCharRegex = RE{+    reString = reHlCStringChar+  , reCompiled = Just $ compileRegex False reHlCStringChar+  , reCaseSensitive = False+  }++reHlCStringChar :: BS.ByteString+reHlCStringChar = "\\\\(?:[abefnrtv\"'?\\\\]|[xX][a-fA-F0-9]+|0[0-7]+)"++hlCCharRegex :: RE+hlCCharRegex = RE{+    reString = reStr+  , reCompiled = Just $ compileRegex False reStr+  , reCaseSensitive = False+  }+  where reStr = "'(?:" <> reHlCStringChar <> "|[^'\\\\])'"++wordDetect :: Bool -> Text -> TokenizerM Text+wordDetect caseSensitive s = do+  res <- stringDetect caseSensitive s+  -- now check for word boundary:  (TODO: check to make sure this is correct)+  inp <- gets input+  case Text.uncons inp of+       Just (c, _) | not (isAlphaNum c) -> return res+       _           -> mzero++stringDetect :: Bool -> Text -> TokenizerM Text+stringDetect caseSensitive s = do+  inp <- gets input+  let len = Text.length s+  let t = Text.take len inp+  -- we assume here that the case fold will not change length,+  -- which is safe for ASCII keywords and the like...+  let matches = if caseSensitive+                   then s == t+                   else mk s == mk t+  if matches+     then takeChars len+     else mzero++-- This assumes that nothing significant will happen+-- in the middle of a string of spaces or a string+-- of alphanumerics.  This seems true  for all normal+-- programming languages, and the optimization speeds+-- things up a lot, relative to just parsing one char.+normalChunk :: TokenizerM Text+normalChunk = do+  inp <- gets input+  case Text.uncons inp of+    Nothing -> mzero+    Just (c, t)+      | c == ' ' ->+        takeChars $ 1 + maybe 0 id (Text.findIndex (/=' ') t)+      | isAlphaNum c ->+        takeChars $ 1 + maybe 0 id (Text.findIndex (not . isAlphaNum) t)+      | otherwise -> takeChars 1++includeRules :: Maybe TokenType -> ContextName -> TokenizerM (Maybe Token)+includeRules mbattr (syn, con) = do+  syntaxes <- asks syntaxMap+  case Map.lookup syn syntaxes >>= lookupContext con of+       Nothing  -> throwError $ "Context lookup failed " ++ show (syn, con)+       Just c   -> do+         mbtok <- msum (map tryRule (cRules c))+         checkLineEnd c+         return $ case (mbtok, mbattr) of+                    (Just (NormalTok, xs), Just attr) ->+                       Just (attr, xs)+                    _ -> mbtok++checkLineEnd :: Context -> TokenizerM ()+checkLineEnd c = do+  inp <- gets input+  when (Text.null inp) $ do+    lineCont' <- gets lineContinuation+    unless lineCont' $ doContextSwitch (cLineEndContext c)++detectChar :: Bool -> Char -> TokenizerM Text+detectChar dynamic c = do+  c' <- if dynamic && c >= '0' && c <= '9'+           then getDynamicChar c+           else return c+  inp <- gets input+  case Text.uncons inp of+    Just (x,_) | x == c' -> takeChars 1+    _          -> mzero++getDynamicChar :: Char -> TokenizerM Char+getDynamicChar c = do+  let capNum = ord c - ord '0'+  res <- getCapture capNum+  case Text.uncons res of+       Nothing    -> mzero+       Just (d,_) -> return d++detect2Chars :: Bool -> Char -> Char -> TokenizerM Text+detect2Chars dynamic c d = do+  c' <- if dynamic && c >= '0' && c <= '9'+           then getDynamicChar c+           else return c+  d' <- if dynamic && d >= '0' && d <= '9'+           then getDynamicChar d+           else return d+  inp <- gets input+  if (Text.pack [c',d']) `Text.isPrefixOf` inp+     then takeChars 2+     else mzero++rangeDetect :: Char -> Char -> TokenizerM Text+rangeDetect c d = do+  inp <- gets input+  case Text.uncons inp of+    Just (x, rest)+      | x == c -> case Text.span (/= d) rest of+                       (in_t, out_t)+                         | Text.null out_t -> mzero+                         | otherwise -> takeChars (Text.length in_t + 2)+    _ -> mzero++detectSpaces :: TokenizerM Text+detectSpaces = do+  inp <- gets input+  case Text.span isSpace inp of+       (t, _)+         | Text.null t -> mzero+         | otherwise   -> takeChars (Text.length t)++detectIdentifier :: TokenizerM Text+detectIdentifier = do+  inp <- gets input+  case Text.uncons inp of+    Just (c, t) | isLetter c || c == '_' ->+      takeChars $ 1 + maybe 0 id (Text.findIndex (\d ->+                        not (isAlphaNum d || d == '_')) t)+    _ -> mzero++lineContinue :: TokenizerM Text+lineContinue = do+  inp <- gets input+  if inp == "\\"+     then do+       modify $ \st -> st{ lineContinuation = True }+       takeChars 1+     else mzero++anyChar :: [Char] -> TokenizerM Text+anyChar cs = do+  inp <- gets input+  case Text.uncons inp of+     Just (x, _) | x `elem` cs -> takeChars 1+     _           -> mzero++regExpr :: Bool -> RE -> TokenizerM Text+regExpr dynamic re = do+  reStr <- if dynamic+              then subDynamic (reString re)+              else return (reString re)+  -- note, for dynamic regexes rCompiled == Nothing:+  let regex = fromMaybe (compileRegex (reCaseSensitive re) reStr)+                 $ reCompiled re+  inp <- gets input+  prev <- gets prevChar+  -- we keep one preceding character, so initial \b can match:+  let target = encodeUtf8 $+               if prev == '\n'+                  then Text.cons ' ' inp+                  else Text.cons prev inp+  case matchRegex regex target of+       Just (match:capts) -> do+         match' <- decodeBS $ BS.drop 1 match -- drop the prevchar+         capts' <- mapM decodeBS capts+         modify $ \st -> st{ captures = capts' }+         takeChars (Text.length match')+       _ -> mzero++decodeBS :: BS.ByteString -> TokenizerM Text+decodeBS bs = case decodeUtf8' bs of+                    Left _ -> throwError ("ByteString " +++                                show bs ++ "is not UTF8")+                    Right t -> return t++-- Substitute out %1, %2, etc. in regex string, escaping+-- appropriately..+subDynamic :: BS.ByteString -> TokenizerM BS.ByteString+subDynamic bs+  | BS.null bs = return BS.empty+  | otherwise  =+    case BS.unpack (BS.take 2 bs) of+        ['%',x] | x >= '0' && x <= '9' -> do+           let capNum = ord x - ord '0'+           let escapeRegexChar c+                | c `elem` ['^','$','\\','[',']','(',')','{','}','*','+','.','?']+                            = BS.pack ['\\',c]+                | otherwise = BS.singleton c+           let escapeRegex = BS.concatMap escapeRegexChar+           replacement <- getCapture capNum+           (escapeRegex (encodeUtf8 replacement) <>) <$> subDynamic (BS.drop 2 bs)+        _ -> case BS.break (=='%') bs of+                  (y,z)+                    | BS.null y -> BS.cons '%' <$> subDynamic z+                    | BS.null z -> return y+                    | otherwise -> (y <>) <$> subDynamic z++getCapture :: Int -> TokenizerM Text+getCapture capnum = do+  capts <- gets captures+  if length capts < capnum+     then mzero+     else return $ capts !! (capnum - 1)++keyword :: KeywordAttr -> WordSet Text -> TokenizerM Text+keyword kwattr kws = do+  prev <- gets prevChar+  guard $ prev `Set.member` (keywordDelims kwattr)+  inp <- gets input+  let (w,_) = Text.break (`Set.member` (keywordDelims kwattr)) inp+  guard $ not (Text.null w)+  let numchars = Text.length w+  case kws of+       CaseSensitiveWords ws   | w `Set.member` ws -> takeChars numchars+       CaseInsensitiveWords ws | mk w `Set.member` ws -> takeChars numchars+       _                       -> mzero++normalizeHighlighting :: [Token] -> [Token]+normalizeHighlighting [] = []+normalizeHighlighting ((t,x):xs)+  | Text.null x = normalizeHighlighting xs+  | otherwise =+    (t, Text.concat (x : map snd matches)) : normalizeHighlighting rest+    where (matches, rest) = span (\(z,_) -> z == t) xs++integerRegex :: RE+integerRegex = RE{+    reString = intReStr+  , reCompiled = Just $ compileRegex False intReStr+  , reCaseSensitive = False+  }+  where intReStr = "\\b[-+]?(0[Xx][0-9A-Fa-f]+|0[Oo][0-7]+|[0-9]+)\\b"++floatRegex :: RE+floatRegex = RE{+    reString = floatReStr+  , reCompiled = Just $ compileRegex False floatReStr+  , reCaseSensitive = False+  }+  where floatReStr = "\\b[-+]?(([0-9]+\\.[0-9]*|[0-9]*\\.[0-9]+)([Ee][-+]?[0-9]+)?|[0-9]+[Ee][-+]?[0-9]+)\\b"++octRegex :: RE+octRegex = RE{+    reString = octRegexStr+  , reCompiled = Just $ compileRegex False octRegexStr+  , reCaseSensitive = False+  }+  where octRegexStr = "\\b[-+]?0[Oo][0-7]+\\b"++hexRegex :: RE+hexRegex = RE{+    reString = hexRegexStr+  , reCompiled = Just $ compileRegex False hexRegexStr+  , reCaseSensitive = False+  }+  where hexRegexStr = "\\b[-+]?0[Xx][0-9A-Fa-f]+\\b"+
+ src/Skylighting/Types.hs view
@@ -0,0 +1,332 @@+{-# LANGUAGE DeriveDataTypeable   #-}+{-# LANGUAGE FlexibleInstances    #-}+{-# LANGUAGE OverloadedStrings    #-}+{-# LANGUAGE ScopedTypeVariables  #-}+{-# LANGUAGE TypeSynonymInstances #-}++module Skylighting.Types (+              -- * Syntax descriptions+                ContextName+              , KeywordAttr(..)+              , WordSet(..)+              , makeWordSet+              , Matcher(..)+              , Rule(..)+              , Context(..)+              , ContextSwitch(..)+              , Syntax(..)+              , SyntaxMap+              -- * Tokens+              , Token+              , TokenType(..)+              , SourceLine+              -- * Styles+              , TokenStyle(..)+              , defStyle+              , Color(..)+              , ToColor(..)+              , FromColor(..)+              , Style(..)+              -- * Format options+              , FormatOptions(..)+              , defaultFormatOpts+              ) where++import Data.Aeson+import Data.Bits+import Data.CaseInsensitive (CI, FoldCase, mk)+import Data.Data (Data)+import qualified Data.Map as Map+import qualified Data.Set as Set+import Data.Text (Text)+import qualified Data.Text as Text+import Data.Typeable (Typeable)+import Data.Word+import Safe (readMay)+import Skylighting.Regex+import Text.Printf++-- | Full name of a context: the first member of the pair is the full+-- syntax name, the second the context name within that syntax.+type ContextName = (Text, Text)++data KeywordAttr =+  KeywordAttr  { keywordCaseSensitive :: Bool+               , keywordDelims        :: Set.Set Char+               }++-- we have a custom show instance solely in order to get+-- parentheses around the (Data.Set.fromList ...) part.+instance Show KeywordAttr where+  show k = "KeywordAttr{ keywordCaseSensitive = " +++            show (keywordCaseSensitive k) +++           ", keywordDelims = (Data.Set." ++ show (keywordDelims k) ++ ")}"++data WordSet a = CaseSensitiveWords (Set.Set a)+               | CaseInsensitiveWords (Set.Set (CI a))++-- | A set of words to match (either case-sensitive or case-insensitive).+makeWordSet :: (FoldCase a, Ord a) => Bool -> [a] -> WordSet a+makeWordSet True ws  = CaseSensitiveWords (Set.fromList ws)+makeWordSet False ws = CaseInsensitiveWords (Set.map mk (Set.fromList ws))++instance Show a => Show (WordSet a) where+  show (CaseSensitiveWords s) =+    "(makeWordSet True " ++ show (Set.toList s) ++ ")"+  show (CaseInsensitiveWords s) =+    "(makeWordSet False " ++ show (Set.toList s) ++ ")"++data Matcher =+    DetectChar Char+  | Detect2Chars Char Char+  | AnyChar [Char]+  | RangeDetect Char Char+  | StringDetect Text+  | WordDetect Text+  | RegExpr RE+  | Keyword KeywordAttr (WordSet Text)+  | Int+  | Float+  | HlCOct+  | HlCHex+  | HlCStringChar+  | HlCChar+  | LineContinue+  | IncludeRules ContextName+  | DetectSpaces+  | DetectIdentifier+  deriving (Show)++data ContextSwitch =+  Pop | Push ContextName+  deriving Show++-- | A rule corresponds to one of the elements of a Kate syntax+-- highlighting "context."+data Rule = Rule{+    rMatcher          :: Matcher+  , rAttribute        :: TokenType+  , rIncludeAttribute :: Bool+  , rDynamic          :: Bool+  , rCaseSensitive    :: Bool+  , rChildren         :: [Rule]+  , rLookahead        :: Bool+  , rFirstNonspace    :: Bool+  , rColumn           :: Maybe Int+  , rContextSwitch    :: [ContextSwitch]+  } deriving (Show)++-- | A syntax corresponds to a complete Kate syntax description.+-- The 'sShortname' field is derived from the filename.+data Syntax = Syntax{+    sName            :: Text+  , sFilename        :: String+  , sShortname       :: Text+  , sContexts        :: Map.Map Text Context+  , sAuthor          :: Text+  , sVersion         :: Text+  , sLicense         :: Text+  , sExtensions      :: [String]+  , sStartingContext :: Text+  } deriving (Show)++-- | A map of syntaxes, keyed by full name.+type SyntaxMap = Map.Map Text Syntax++-- | A Context corresponds to a context element in a Kate+-- syntax description.+data Context = Context{+    cName               :: Text+  , cSyntax             :: Text+  , cRules              :: [Rule]+  , cAttribute          :: TokenType+  , cLineEmptyContext   :: [ContextSwitch]+  , cLineEndContext     :: [ContextSwitch]+  , cLineBeginContext   :: [ContextSwitch]+  , cFallthrough        :: Bool+  , cFallthroughContext :: [ContextSwitch]+  , cDynamic            :: Bool+} deriving (Show)++-- | A pair consisting of a list of attributes and some text.+type Token = (TokenType, Text)++-- | 'KeywordTok' corresponds to @dsKeyword@ in Kate syntax+-- descriptions, and so on.+data TokenType = KeywordTok+               | DataTypeTok+               | DecValTok+               | BaseNTok+               | FloatTok+               | ConstantTok+               | CharTok+               | SpecialCharTok+               | StringTok+               | VerbatimStringTok+               | SpecialStringTok+               | ImportTok+               | CommentTok+               | DocumentationTok+               | AnnotationTok+               | CommentVarTok+               | OtherTok+               | FunctionTok+               | VariableTok+               | ControlFlowTok+               | OperatorTok+               | BuiltInTok+               | ExtensionTok+               | PreprocessorTok+               | AttributeTok+               | RegionMarkerTok+               | InformationTok+               | WarningTok+               | AlertTok+               | ErrorTok+               | NormalTok+               deriving (Read, Show, Eq, Ord, Enum, Data, Typeable)++-- | JSON @"Keyword"@ corresponds to 'KeywordTok', and so on.+instance FromJSON TokenType where+  parseJSON (String t) =+    case readMay (Text.unpack t ++ "Tok") of+         Just tt -> return tt+         Nothing -> fail "Not a token type"+  parseJSON _ = mempty++-- | A line of source: a list of labeled tokens.+type SourceLine = [Token]++-- | A 'TokenStyle' determines how a token is to be rendered.+data TokenStyle = TokenStyle {+    tokenColor      :: Maybe Color+  , tokenBackground :: Maybe Color+  , tokenBold       :: Bool+  , tokenItalic     :: Bool+  , tokenUnderline  :: Bool+  } deriving (Show, Read, Ord, Eq, Data, Typeable)++-- | The keywords used in KDE syntax+-- themes are used, e.g. @text-color@ for default token color.+instance FromJSON TokenStyle where+  parseJSON (Object v) = do+    tcolor <- v .:? "text-color"+    tbold <- v .:? "bold" .!= False+    titalic <- v .:? "italic" .!= False+    tunderline <- v .:? "underline" .!= False+    return TokenStyle{+               tokenColor = tcolor+             , tokenBackground = Nothing+             , tokenBold = tbold+             , tokenItalic = titalic+             , tokenUnderline = tunderline }+  parseJSON _ = mempty++-- | Default style.+defStyle :: TokenStyle+defStyle = TokenStyle {+    tokenColor      = Nothing+  , tokenBackground = Nothing+  , tokenBold       = False+  , tokenItalic     = False+  , tokenUnderline  = False+  }++-- A color (red/green/blue).+data Color = RGB Word8 Word8 Word8+  deriving (Show, Read, Ord, Eq, Data, Typeable)++class ToColor a where+  toColor :: a -> Maybe Color++instance ToColor String where+  toColor ['#',r1,r2,g1,g2,b1,b2] =+     case reads ['(','0','x',r1,r2,',','0','x',g1,g2,',','0','x',b1,b2,')'] of+           ((r,g,b),_) : _ -> Just $ RGB r g b+           _               -> Nothing+  toColor _        = Nothing++instance ToColor Int where+  toColor x = toColor (fromIntegral x1 :: Word8,+                       fromIntegral x2 :: Word8,+                       fromIntegral x3 :: Word8)+    where x1 = (shiftR x 16) .&. 0xFF+          x2 = (shiftR x 8 ) .&. 0xFF+          x3 = x             .&. 0xFF++instance ToColor (Word8, Word8, Word8) where+  toColor (r,g,b) = Just $ RGB r g b++instance ToColor (Double, Double, Double) where+  toColor (r,g,b) | r >= 0 && g >= 0 && b >= 0 && r <= 1 && g <= 1 && b <= 1 =+          Just $ RGB (floor $ r * 255) (floor $ g * 255) (floor $ b * 255)+  toColor _ = Nothing++-- | JSON @"#1aff2b" corresponds to the color @RGB 0x1a 0xff 0x2b@.+instance FromJSON Color where+  parseJSON (String t) = maybe mempty return $ toColor (Text.unpack t)+  parseJSON _          = mempty++class FromColor a where+  fromColor :: Color -> a++instance FromColor String where+  fromColor (RGB r g b) = printf "#%02x%02x%02x" r g b++instance FromColor (Double, Double, Double) where+  fromColor (RGB r g b) = (fromIntegral r / 255, fromIntegral g / 255, fromIntegral b / 255)++instance FromColor (Word8, Word8, Word8) where+  fromColor (RGB r g b) = (r, g, b)++-- | A rendering style. This determines how each kind of token+-- is to be rendered, and sets a default color and background+-- color for normal tokens.  Line numbers can have a different+-- color and background color.+data Style = Style {+    tokenStyles               :: [(TokenType, TokenStyle)]+  , defaultColor              :: Maybe Color+  , backgroundColor           :: Maybe Color+  , lineNumberColor           :: Maybe Color+  , lineNumberBackgroundColor :: Maybe Color+  } deriving (Read, Show, Eq, Ord, Data, Typeable)++-- | The FromJSON instance for 'Style' is designed so that+-- a KDE syntax theme (JSON) can be decoded directly as a+-- 'Style'.+instance FromJSON Style where+  parseJSON (Object v) = do+    (tokstyles :: Map.Map Text TokenStyle) <- v .: "text-styles"+    (editorColors :: Map.Map Text Color) <- v .: "editor-colors"+    return Style{ defaultColor = case Map.lookup "Normal" tokstyles of+                                      Nothing -> Nothing+                                      Just ts -> tokenColor ts+                , backgroundColor = Map.lookup "background-color" editorColors+                , lineNumberColor = Map.lookup "line-numbers" editorColors+                , lineNumberBackgroundColor = Map.lookup "background-color"+                                                editorColors+                , tokenStyles = Map.toList $+                     Map.mapKeys (\s -> maybe OtherTok id $+                                     readMay (Text.unpack s ++ "Tok")) tokstyles }+  parseJSON _ = mempty++-- | Options for formatting source code.+data FormatOptions = FormatOptions{+         numberLines      :: Bool     -- ^ Number lines+       , startNumber      :: Int      -- ^ Number of first line+       , lineAnchors      :: Bool     -- ^ Anchors on each line number+       , titleAttributes  :: Bool     -- ^ Html titles with token types+       , codeClasses      :: [Text]   -- ^ Additional classes for Html code tag+       , containerClasses :: [Text]   -- ^ Additional classes for Html container tag+                                      --   (pre or table depending on numberLines)+       } deriving (Eq, Show, Read)++defaultFormatOpts :: FormatOptions+defaultFormatOpts = FormatOptions{+                      numberLines = False+                    , startNumber = 1+                    , lineAnchors = False+                    , titleAttributes = False+                    , codeClasses = []+                    , containerClasses = []+                    }
+ test/cases/abc.ada view
@@ -0,0 +1,79 @@+with Ada.Characters.Handling;+use Ada.Characters.Handling;+++package Abc is+    type Block_Faces is array(1..2) of Character;+    type Block_List is array(positive range <>) of Block_Faces;+    function Can_Make_Word(W: String; Blocks: Block_List) return Boolean;+end Abc;+++package body Abc is++function Can_Make_Word(W: String; Blocks: Block_List) return Boolean is+    Used : array(Blocks'Range) of Boolean := (Others => False);+    subtype wIndex is Integer range W'First..W'Last;+    wPos : wIndex;+begin+    if W'Length = 0 then+        return True;+    end if;+    wPos := W'First;+    while True loop+        declare+            C : Character := To_Upper(W(wPos));+            X : constant wIndex := wPos;+        begin+            for I in Blocks'Range loop+                if (not Used(I)) then+                    if C = To_Upper(Blocks(I)(1)) or C = To_Upper(Blocks(I)(2)) then+                        Used(I) := True;+                        if wPos = W'Last then+                            return True;+                        end if;+                        wPos := wIndex'Succ(wPos);+                        exit;+                    end if;+                end if;+            end loop;+            if X = wPos then+                return False;+            end if;+        end;+    end loop;+    return False;+end Can_Make_Word;++end Abc;++with Ada.Text_IO, Ada.Strings.Unbounded, Abc;+use Ada.Text_IO, Ada.Strings.Unbounded, Abc;++procedure Abc_Problem is+    Blocks : Block_List := (+          ('B','O'), ('X','K'), ('D','Q'), ('C','P')+        , ('N','A'), ('G','T'), ('R','E'), ('T','G')+        , ('Q','D'), ('F','S'), ('J','W'), ('H','U')+        , ('V','I'), ('A','N'), ('O','B'), ('E','R')+        , ('F','S'), ('L','Y'), ('P','C'), ('Z','M')+    );+    function "+" (S : String) return Unbounded_String renames To_Unbounded_String;+    words : array(positive range <>) of Unbounded_String := (+          +"A"+        , +"BARK"+        , +"BOOK"+        , +"TREAT"+        , +"COMMON"+        , +"SQUAD"+        , +"CONFUSE"+        -- Border cases:+        -- , +"CONFUSE2"+        -- , +""+    );+begin+    for I in words'Range loop+        Put_Line ( To_String(words(I)) & ": " & Boolean'Image(Can_Make_Word(To_String(words(I)),Blocks)) );+    end loop;+end Abc_Problem;+
+ test/cases/abc.agda view
@@ -0,0 +1,40 @@+module Reals where++  -- (a set with properties of) the reals+  data ℝ : Set where+    r0 : ℝ+    r1 : ℝ+    _+_ : ℝ → ℝ → ℝ++  -- equality+  data _==_ : ℝ → ℝ → Set where+    AXrefl== : ∀ {r} → r == r+    AXsymm== : ∀ {r s} → r == s → s == r+    AXtrans== : ∀ {r s t} → r == s → s == t → r == t+    AX+0 : ∀ {r} → (r + r0) == r+    AXsymm+ : ∀ {r s} → (r + s) == (s + r)+    AX+== : ∀ {r s t} → r == s → (r + t) == (s + t)++  THM0+ : {r : ℝ} → r == (r0 + r)+  THM0+ = AXsymm== (AXtrans== AXsymm+ AX+0)+  -- AXsymm+ AX+0   r0 + r == r + r0 and r + r0 == r+  -- AXtrans==      so r0 + r == r+  -- AXsymm==       so r == r0 + r++  THM0+alt : {r : ℝ} → r == (r0 + r)+  THM0+alt {r} = AXsymm== {r0 + r} {r} ((AXtrans== {r0 + r} {r + r0} {r}) (AXsymm+ {r0} {r}) (AX+0 {r}))++  -- strict partial ordering+  data _<_ : ℝ → ℝ → Set where+    AXtrans<<< : ∀ {r s t} → r < s → s < t → r < t+    AX<=< : ∀ {r s t} → r < s → s == t → r < t+    AX=<< : ∀ {r s t} → r == s → s < t → r < t+    AX0<1 : r0 < r1+    AX+<< : ∀ {r s t} → r < s → (r + t) < (s + t)++  THM<+1 : {r : ℝ} → r < (r + r1)+  THM<+1 = AX<=< (AX=<< THM0+ (AX+<< AX0<1)) AXsymm++  -- AX0<1              0 < 1+  -- AX<+ %             so 0 + r < 1 + r+  -- AX=<< lem0+ %      so r < 1 + r+  -- AX<=< % AXsymm+    so r < r + 1
+ test/cases/abc.c view
@@ -0,0 +1,41 @@+#include <stdio.h>+#include <ctype.h>++int can_make_words(char **b, char *word)+{+        int i, ret = 0, c = toupper(*word);++#define SWAP(a, b) if (a != b) { char * tmp = a; a = b; b = tmp; }++        if (!c) return 1;+        if (!b[0]) return 0;++        for (i = 0; b[i] && !ret; i++) {+                if (b[i][0] != c && b[i][1] != c) continue;+                SWAP(b[i], b[0]);+                ret = can_make_words(b + 1, word + 1);+                SWAP(b[i], b[0]);+        }++        return ret;+}++int main(void)+{+        char* blocks[] = {+                "BO", "XK", "DQ", "CP", "NA", +                "GT", "RE", "TG", "QD", "FS", +                "JW", "HU", "VI", "AN", "OB", +                "ER", "FS", "LY", "PC", "ZM",+                0 };++        char *words[] = {+                "", "A", "BARK", "BOOK", "TREAT", "COMMON", "SQUAD", "Confuse", 0+        };++        char **w;+        for (w = words; *w; w++)+                printf("%s\t%d\n", *w, can_make_words(blocks, *w));++        return 0;+}
+ test/cases/abc.clojure view
@@ -0,0 +1,22 @@++(def blocks+  (-> "BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM" (.split " ") vec))++(defn omit +  "return bs with (one instance of) b omitted"+  [bs b] +  (let [[before after] (split-with #(not= b %) bs)]+    (concat before (rest after))))++(defn abc +  "return lazy sequence of solutions (i.e. block lists)"+  [blocks [c & cs]]+  (if-some c+    (for [b blocks :when (some #(= c %) b)+          bs (abc (omit blocks b) cs)]+      (cons b bs))+    [[]]))+    +      +(doseq [word ["A" "BARK" "Book" "treat" "COMMON" "SQUAD" "CONFUSE"]]+  (->> word .toUpperCase (abc blocks) first (printf "%s: %b\n" word)))
+ test/cases/abc.cpp view
@@ -0,0 +1,37 @@+#include <iostream>+#include <vector>+#include <string>+#include <set>+#include <cctype>+++typedef std::pair<char,char> item_t;+typedef std::vector<item_t> list_t;++bool can_make_word(const std::string& w, const list_t& vals) {+    std::set<uint32_t> used;+    while (used.size() < w.size()) {+        const char c = toupper(w[used.size()]);+        uint32_t x = used.size();+        for (uint32_t i = 0, ii = vals.size(); i < ii; ++i) {+            if (used.find(i) == used.end()) {+                if (toupper(vals[i].first) == c || toupper(vals[i].second) == c) {+                    used.insert(i);+                    break;+                }+            }+        }+        if (x == used.size()) break;+    }+    return used.size() == w.size();+}+++int main() {+    list_t vals{ {'B','O'}, {'X','K'}, {'D','Q'}, {'C','P'}, {'N','A'}, {'G','T'}, {'R','E'}, {'T','G'}, {'Q','D'}, {'F','S'}, {'J','W'}, {'H','U'}, {'V','I'}, {'A','N'}, {'O','B'}, {'E','R'}, {'F','S'}, {'L','Y'}, {'P','C'}, {'Z','M'} };+    std::vector<std::string> words{"A","BARK","BOOK","TREAT","COMMON","SQUAD","CONFUSE"};+    for (const std::string& w : words) {+        std::cout << w << ": " << std::boolalpha << can_make_word(w,vals) << ".\n";+    }++}
+ test/cases/abc.cs view
@@ -0,0 +1,83 @@+using System.Collections.Generic;+using System.Linq;++void Main()+{+        List<string> blocks =+        new List<string>() { "bo", "xk", "dq", "cp", "na", "gt", "re", "tg", "qd", "fs",+                "jw", "hu", "vi", "an", "ob", "er", "fs", "ly", "pc", "zm" };+        List<string> words = new List<string>() {+                "A", "BARK", "BOOK", "TREAT", "COMMON", "SQUAD", "CONFUSE"};+        +        var solver = new ABC(blocks);+        +        foreach( var word in words)+        {+                Console.WriteLine("{0} :{1}", word, solver.CanMake(word));+        }+}++class ABC+{+        readonly Dictionary<char, List<int>> _blockDict = new Dictionary<char, List<int>>();+        bool[] _used;+        int _nextBlock;++        readonly List<string> _blocks;++        private void AddBlockChar(char c)+        {+                if (!_blockDict.ContainsKey(c))+                {+                        _blockDict[c] = new List<int>();+                }+                _blockDict[c].Add(_nextBlock);+        }++        private void AddBlock(string block)+        {+                AddBlockChar(block[0]);+                AddBlockChar(block[1]);+                _nextBlock++;+        }++        public ABC(List<string> blocks)+        {+                _blocks = blocks;+                foreach (var block in blocks)+                {+                        AddBlock(block);+                }+        }++        public bool CanMake(string word)+        {+                word = word.ToLower();+                if (word.Length > _blockDict.Count)+                {+                        return false;+                }+                _used = new bool[_blocks.Count];+                return TryMake(word);+        }++        public bool TryMake(string word)+        {+                if (word == string.Empty)+                {+                        return true;+                }+                var blocks = _blockDict[word[0]].Where(b => !_used[b]);+                foreach (var block in blocks)+                {+                        _used[block] = true;+                        if (TryMake(word.Substring(1)))+                        {+                                return true;+                        }+                        _used[block] = false;+                }+                return false;+        }+}+
+ test/cases/abc.d view
@@ -0,0 +1,42 @@+import std.stdio, std.ascii, std.algorithm, std.array, std.range;++alias Block = char[2];++bool canMakeWord(immutable Block[] blocks, in string word) pure nothrow+in {+    assert(blocks.all!(w => w[].all!isAlpha));+    assert(word.all!isAlpha);+} body {+    bool inner(size_t[] indexes, in string w) pure nothrow {+        if (w.empty)+            return true;++        immutable c = w[0].toUpper;+        foreach (ref idx; indexes) {+            if (blocks[idx][0].toUpper != c &&+                blocks[idx][1].toUpper != c)+                continue;+            indexes[0].swap(idx);+            if (inner(indexes[1 .. $], w[1 .. $]))+                return true;+            indexes[0].swap(idx);+        }++        return false;+    }++    return inner(blocks.length.iota.array, word);+}++void main() {+    enum Block[] blocks = "BO XK DQ CP NA GT RE TG QD FS+                           JW HU VI AN OB ER FS LY PC ZM".split;++    foreach (w; "" ~ "A BARK BoOK TrEAT COmMoN SQUAD conFUsE".split)+        writefln(`"%s" %s`, w, blocks.canMakeWord(w));++    // Extra test.+    immutable Block[] blocks2 = ["AB", "AB", "AC", "AC"];+    immutable word = "abba";+    writefln(`"%s" %s`, word, blocks2.canMakeWord(word));+}
+ test/cases/abc.fortran view
@@ -0,0 +1,70 @@+!-*- mode: compilation; default-directory: "/tmp/" -*-+!Compilation started at Thu Jun  5 01:52:03+!+!make f && for a in '' a bark book treat common squad confuse ; do echo $a | ./f ; done+!gfortran -std=f2008 -Wall -fopenmp -ffree-form -fall-intrinsics -fimplicit-none -g f.f08 -o f+! T                      +! T  A                    NA+! T  BARK                 BO NA RE XK+! F  BOOK                 OB BO -- --+! T  TREAT                GT RE ER NA TG+! F  COMMON               PC OB ZM -- -- --+! T  SQUAD                FS DQ HU NA QD+! T  CONFUSE              CP BO NA FS HU FS RE+!+!Compilation finished at Thu Jun  5 01:52:03++program abc+  implicit none+  integer, parameter :: nblocks = 20+  character(len=nblocks) :: goal+  integer, dimension(nblocks) :: solution+  character(len=2), dimension(0:nblocks) :: blocks_copy, blocks = &+       &(/'--','BO','XK','DQ','CP','NA','GT','RE','TG','QD','FS','JW','HU','VI','AN','OB','ER','FS','LY','PC','ZM'/)+  logical :: valid+  integer :: i, iostat+  read(5,*,iostat=iostat) goal+  if (iostat .ne. 0) goal = ''+  call ucase(goal)+  solution = 0+  blocks_copy = blocks+  valid = assign_block(goal(1:len_trim(goal)), blocks, solution, 1)+  write(6,*) valid, ' '//goal, (' '//blocks_copy(solution(i)), i=1,len_trim(goal))++contains++  recursive function assign_block(goal, blocks, solution, n) result(valid)+    implicit none+    logical :: valid+    character(len=*), intent(in) :: goal+    character(len=2), dimension(0:), intent(inout) :: blocks+    integer, dimension(:), intent(out) :: solution+    integer, intent(in) :: n+    integer :: i+    character(len=2) :: backing_store+    valid = .true.+    if (len(goal)+1 .eq. n) return+    do i=1, size(blocks)+       if (index(blocks(i),goal(n:n)) .ne. 0) then+          backing_store = blocks(i)+          blocks(i) = ''+          solution(n) = i+          if (assign_block(goal, blocks, solution, n+1)) return+          blocks(i) = backing_store+       end if+    end do+    valid = .false.+    return+  end function assign_block++  subroutine ucase(a)+    implicit none+    character(len=*), intent(inout) :: a+    integer :: i, j+    do i = 1, len_trim(a)+       j = index('abcdefghijklmnopqrstuvwxyz',a(i:i))+       if (j .ne. 0) a(i:i) = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'(j:j)+    end do+  end subroutine ucase++end program abc
+ test/cases/abc.go view
@@ -0,0 +1,39 @@+package main++import (+        "fmt"+        "strings"+)++func newSpeller(blocks string) func(string) bool {+        bl := strings.Fields(blocks)+        return func(word string) bool {+                return r(word, bl)+        }+}++func r(word string, bl []string) bool {+        if word == "" {+                return true+        }+        c := word[0] | 32+        for i, b := range bl {+                if c == b[0]|32 || c == b[1]|32 {+                        bl[i], bl[0] = bl[0], b+                        if r(word[1:], bl[1:]) == true {+                                return true+                        }+                        bl[i], bl[0] = bl[0], bl[i]+                }+        }+        return false+}++func main() {+        sp := newSpeller(+                "BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM")+        for _, word := range []string{+                "A", "BARK", "BOOK", "TREAT", "COMMON", "SQUAD", "CONFUSE"} {+                fmt.Println(word, sp(word))+        }+}
+ test/cases/abc.haskell view
@@ -0,0 +1,15 @@+import Data.List (delete)+import Data.Char (toUpper)++-- returns list of all solutions, each solution being a list of blocks+abc :: (Eq a) => [[a]] -> [a] -> [[[a]]]+abc _ [] = [[]]+abc blocks (c:cs) = [b:ans | b <- blocks, c `elem` b,+                             ans <- abc (delete b blocks) cs]++blocks = ["BO", "XK", "DQ", "CP", "NA", "GT", "RE", "TG", "QD", "FS",+          "JW", "HU", "VI", "AN", "OB", "ER", "FS", "LY", "PC", "ZM"]++main :: IO ()+main = mapM_ (\w -> print (w, not . null $ abc blocks (map toUpper w)))+         ["", "A", "BARK", "BoOK", "TrEAT", "COmMoN", "SQUAD", "conFUsE"]
+ test/cases/abc.java view
@@ -0,0 +1,44 @@+import java.util.Arrays;++public class ABC{+        private static void swap(int i, int j, Object... arr){+                Object tmp = arr[i];+                arr[i] = arr[j];+                arr[j] = tmp;+        }+        +        public static boolean canMakeWord(String word, String... blocks) {+            if(word.length() == 0)+                return true;+         +            char c = Character.toUpperCase(word.charAt(0));+            for(int i = 0; i < blocks.length; i++) {+                String b = blocks[i];+                if(Character.toUpperCase(b.charAt(0)) != c && Character.toUpperCase(b.charAt(1)) != c)+                    continue;+                swap(0, i, blocks);+                if(canMakeWord(word.substring(1), Arrays.copyOfRange(blocks, 1, blocks.length)))+                    return true;+                swap(0, i, blocks);+            }+         +            return false;+        }+        +        public static void main(String[] args){+                String[] blocks = {"BO", "XK", "DQ", "CP", "NA", +                                "GT", "RE", "TG", "QD", "FS", +                                "JW", "HU", "VI", "AN", "OB", +                                "ER", "FS", "LY", "PC", "ZM"};++                System.out.println("\"\": " + canMakeWord("", blocks));+                System.out.println("A: " + canMakeWord("A", blocks));+                System.out.println("BARK: " + canMakeWord("BARK", blocks));+                System.out.println("book: " + canMakeWord("book", blocks));+                System.out.println("treat: " + canMakeWord("treat", blocks));+                System.out.println("COMMON: " + canMakeWord("COMMON", blocks));+                System.out.println("SQuAd: " + canMakeWord("SQuAd", blocks));+                System.out.println("CONFUSE: " + canMakeWord("CONFUSE", blocks));+                +        }+}
+ test/cases/abc.javascript view
@@ -0,0 +1,33 @@+let characters = "BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM";+let blocks = characters.split(" ").map(pair => pair.split(""));+ +function isWordPossible(word) {+  var letters = [...word.toUpperCase()];+  var length = letters.length;+  var copy = new Set(blocks);++  for (let letter of letters) {+    for (let block of copy) {+      let index = block.indexOf(letter);+ +      if (index !== -1) {+        length--;+        copy.delete(block);+        break;  +      }+    }++  }+  return !length;+}    + +[ +  "A", +  "BARK", +  "BOOK", +  "TREAT", +  "COMMON", +  "SQUAD", +  "CONFUSE" +].forEach(word => console.log(`${word}: ${isWordPossible(word)}`));+
+ test/cases/abc.julia view
@@ -0,0 +1,9 @@+function abc (str, list)+  isempty(str) && return true+  for i = 1:length(list)+    str[end] in list[i] && +    any([abc(str[1:end-1], deleteat!(copy(list), i))]) &&+    return true+  end+  false+end
+ test/cases/abc.kotlin view
@@ -0,0 +1,55 @@+import java.util.Arrays++/*+    Swap elements i and j of a Kotlin Array.+ */+fun <T> Array<T>.swap(i: Int, j: Int) {+    val tmp = this[i]+    this[i] = this[j]+    this[j] = tmp+}++data class Block(val block: String)++/*+ *  Not the most elegant way but interesting from an highlighting perspective ;)+ */+public class ABC() {+    class object {++        public fun canMakeWord(word: String, blocks: Array<Block>): Boolean {+            if (word.length() == 0)+                return true++            val c = Character.toUpperCase(word.charAt(0))+            for (i in 0..blocks.size - 1) {+                val b = blocks[i]+                if (Character.toUpperCase(b.block.charAt(0)) != c && Character.toUpperCase(b.block.charAt(1)) != c)+                    continue+                blocks.swap(0, i)+                if (canMakeWord(word.substring(1), Arrays.copyOfRange(blocks, 1, blocks.size)))+                    return true+                blocks.swap(0, i)+            }++            return false+        }++        public fun main(args: Array<String>) {++            val blocksString = array("BO", "XK", "DQ", "CP", "NA", "GT", "RE", "TG", "QD", "FS", "JW",+                                             "HU", "VI", "AN", "OB", "ER", "FS", "LY", "PC", "ZM");++            val blocks = Array(blocksString.size, { s -> Block(blocksString[s])})++            val words = array("", "A", "BARK", "book", "treat", "COMMON", "SQuAd", "CONFUSE");++            for (word in words) {+                System.out.println("${word}: " + canMakeWord("${word}", blocks))+            }++        }+    }+}++fun main(args: Array<String>) = ABC.main(args)
+ test/cases/abc.lisp view
@@ -0,0 +1,15 @@++(defun word-possible-p (word blocks)+  (cond +    ((= (length word) 0) t)+    ((null blocks) nil)+    (t (let* +         ((c (aref word 0))+          (bs (remove-if-not #'(lambda (b) +                                 (find c b :test #'char-equal))+                             blocks)))+         (some #'identity +               (loop for b in bs+                     collect (word-possible-p+                               (subseq word 1)+                               (remove b blocks))))))))
+ test/cases/abc.matlab view
@@ -0,0 +1,26 @@+function testABC+    combos = ['BO' ; 'XK' ; 'DQ' ; 'CP' ; 'NA' ; 'GT' ; 'RE' ; 'TG' ; 'QD' ; ...+        'FS' ; 'JW' ; 'HU' ; 'VI' ; 'AN' ; 'OB' ; 'ER' ; 'FS' ; 'LY' ; ...+        'PC' ; 'ZM'];+    words = {'A' 'BARK' 'BOOK' 'TREAT' 'COMMON' 'SQUAD' 'CONFUSE'};+    for k = 1:length(words)+        possible = canMakeWord(words{k}, combos);+        fprintf('Can%s make word %s.\n', char(~possible.*'NOT'), words{k})+    end+end++function isPossible = canMakeWord(word, combos)+    word = lower(word);+    combos = lower(combos);+    isPossible = true;+    k = 1;+    while isPossible && k <= length(word)+        [r, c] = find(combos == word(k), 1);+        if ~isempty(r)+            combos(r, :) = '';+        else+            isPossible = false;+        end+        k = k+1;+    end+end
+ test/cases/abc.ocaml view
@@ -0,0 +1,40 @@+let blocks = [+  ('B', 'O');  ('X', 'K');  ('D', 'Q');  ('C', 'P');+  ('N', 'A');  ('G', 'T');  ('R', 'E');  ('T', 'G');+  ('Q', 'D');  ('F', 'S');  ('J', 'W');  ('H', 'U');+  ('V', 'I');  ('A', 'N');  ('O', 'B');  ('E', 'R');+  ('F', 'S');  ('L', 'Y');  ('P', 'C');  ('Z', 'M');+]++let find_letter blocks c =+  let found, remaining =+    List.partition (fun (c1, c2) -> c1 = c || c2 = c) blocks+  in+  match found with+  | _ :: res -> Some (res @ remaining)+  | _ -> None++let can_make_word w =+  let n = String.length w in+  let rec aux i _blocks =+    if i >= n then true else+      match find_letter _blocks w.[i] with+      | None -> false+      | Some rem_blocks ->+          aux (succ i) rem_blocks+  in+  aux 0 blocks++let test label f (word, should) =+  Printf.printf "- %s %S = %B  (should: %B)\n" label word (f word) should++let () =+  List.iter (test "can make word" can_make_word) [+    "A", true;+    "BARK", true;+    "BOOK", false;+    "TREAT", true;+    "COMMON", false;+    "SQUAD", true;+    "CONFUSE", true;+  ]
+ test/cases/abc.perl view
@@ -0,0 +1,14 @@+use Test::More tests => 8;++my @blocks1 = qw(BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM);+is(can_make_word("A",       @blocks1), 1);+is(can_make_word("BARK",    @blocks1), 1);+is(can_make_word("BOOK",    @blocks1), undef);+is(can_make_word("TREAT",   @blocks1), 1);+is(can_make_word("COMMON",  @blocks1), undef);+is(can_make_word("SQUAD",   @blocks1), 1);+is(can_make_word("CONFUSE", @blocks1), 1);++my @blocks2 = qw(US TZ AO QA);+is(can_make_word('auto', @blocks2), 1);+
+ test/cases/abc.php view
@@ -0,0 +1,30 @@++<?php+$words = array("A", "BARK", "BOOK", "TREAT", "COMMON", "SQUAD", "Confuse");++function canMakeWord($word) {+    $word = strtoupper($word);+    $blocks = array(+            "BO", "XK", "DQ", "CP", "NA",+            "GT", "RE", "TG", "QD", "FS",+            "JW", "HU", "VI", "AN", "OB",+            "ER", "FS", "LY", "PC", "ZM",+    );++    foreach (str_split($word) as $char) {+        foreach ($blocks as $k => $block) {+            if (strpos($block, $char) !== FALSE) {+                unset($blocks[$k]);+                continue(2);+            }+        }+        return false;+    }+    return true;+}++foreach ($words as $word) {+    echo $word.': ';+    echo canMakeWord($word) ? "True" : "False";+    echo "\r\n";+}
+ test/cases/abc.prolog view
@@ -0,0 +1,23 @@+abc_problem :-+        maplist(abc_problem, ['', 'A', bark, bOOk, treAT, 'COmmon', sQuaD, 'CONFUSE']).+++abc_problem(Word) :-+        L = [[b,o],[x,k],[d,q],[c,p],[n,a],[g,t],[r,e],[t,g],[q,d],[f,s],+             [j,w],[h,u],[v,i],[a,n],[o,b],[e,r],[f,s],[l,y],[p,c],[z,m]],++        (   abc_problem(L, Word)+        ->  format('~w OK~n', [Word])+        ;   format('~w KO~n', [Word])).++abc_problem(L, Word) :-+        atom_chars(Word, C_Words),+        maplist(downcase_atom, C_Words, D_Words),+        can_makeword(L, D_Words).++can_makeword(_L, []).++can_makeword(L, [H | T]) :-+        (   select([H, _], L, L1); select([_, H], L, L1)),+        can_makeword(L1, T).+
+ test/cases/abc.python view
@@ -0,0 +1,16 @@+def mkword(w, b):+    if not w: return []++    c,w = w[0],w[1:]+    for i in range(len(b)):+        if c in b[i]:+            m = mkword(w, b[0:i] + b[i+1:])+            if m != None: return [b[i]] + m++def abc(w, blk):+    return mkword(w.upper(), [a.upper() for a in blk])++blocks = 'BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM'.split()++for w in ", A, bark, book, treat, common, SQUAD, conFUsEd".split(', '):+    print '\'' + w + '\'' + ' ->', abc(w, blocks)
+ test/cases/abc.r view
@@ -0,0 +1,21 @@+canMakeNoRecursion <- function(x) {+  x <- toupper(x)+  charList <- strsplit(x, character(0))+  getCombos <- function(chars) {+    charBlocks <-  data.matrix(expand.grid(lapply(chars, function(char) which(blocks == char, arr.ind=TRUE)[, 1L])))+    charBlocks <- charBlocks[!apply(charBlocks, 1, function(row) any(duplicated(row))), , drop=FALSE]+    if (dim(charBlocks)[1L] > 0L) {+      t(apply(charBlocks, 1, function(row) apply(blocks[row, , drop=FALSE], 1, paste, collapse="")))+    } else {+      character(0)+    }+  }+  setNames(lapply(charList, getCombos), x)+}+canMakeNoRecursion(c("A",+           "BARK",+           "BOOK",+           "TREAT",+           "COMMON",+           "SQUAD",+           "CONFUSE"))
+ test/cases/abc.ruby view
@@ -0,0 +1,8 @@+words = %w(A BaRK BOoK tREaT COmMOn SqUAD CoNfuSE) << ""++words.each do |word|+  blocks = "BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM"+  res = word.each_char.all?{|c| blocks.sub!(/\w?#{c}\w?/i, "")}  #regexps can be interpolated like strings+  puts "#{word.inspect}: #{res}"+end+
+ test/cases/abc.scala view
@@ -0,0 +1,50 @@+object AbcBlocks extends App {++  protected class Block(face1: Char, face2: Char) {++    def isFacedWith(that: Char) = { that == face1 || that == face2 }+    override def toString() = face1.toString + face2+  }+  protected object Block {+    def apply(faces: String) = new Block(faces.head, faces.last)+  }++  type word = Seq[Block]++  private val blocks = List(Block("BO"), Block("XK"), Block("DQ"), Block("CP"), Block("NA"),+    Block("GT"), Block("RE"), Block("TG"), Block("QD"), Block("FS"),+    Block("JW"), Block("HU"), Block("VI"), Block("AN"), Block("OB"),+    Block("ER"), Block("FS"), Block("LY"), Block("PC"), Block("ZM"))++  private def isMakeable(word: String, blocks: word) = {++    def getTheBlocks(word: String, blocks: word) = {++      def inner(word: String, toCompare: word, rest: word, accu: word): word = {+        if (word.isEmpty || rest.isEmpty || toCompare.isEmpty) accu+        else if (toCompare.head.isFacedWith(word.head)) {+          val restant = rest diff List(toCompare.head)+          inner(word.tail, restant, restant, accu :+ toCompare.head)+        } else inner(word, toCompare.tail, rest, accu)+      }+      inner(word, blocks, blocks, Nil)+    }++    word.lengthCompare(getTheBlocks(word, blocks).size) == 0+  }++  val words = List("A", "BARK", "BOOK", "TREAT", "COMMON", "SQUAD", "CONFUSED", "ANBOCPDQERSFTGUVWXLZ")+  // Automatic tests+  assert(isMakeable(words(0), blocks))+  assert(isMakeable(words(1), blocks))+  assert(!isMakeable(words(2), blocks)) // BOOK not+  assert(isMakeable(words(3), blocks))+  assert(!isMakeable(words(4), blocks)) // COMMON not+  assert(isMakeable(words(5), blocks))+  assert(isMakeable(words(6), blocks))+  assert(isMakeable(words(7), blocks))++  //words(7).mkString.permutations.foreach(s => assert(isMakeable(s, blocks)))++  words.foreach(w => println(s"$w can${if (isMakeable(w, blocks)) " " else "not "}be made."))+}
+ test/cases/abc.scheme view
@@ -0,0 +1,43 @@+#lang racket+(define block-strings+  (list "BO" "XK" "DQ" "CP" "NA"+        "GT" "RE" "TG" "QD" "FS"+        "JW" "HU" "VI" "AN" "OB"+        "ER" "FS" "LY" "PC" "ZM"))+(define BLOCKS (map string->list block-strings))++(define (can-make-word? w)+  (define (usable-block blocks word-char)+    (for/first ((b (in-list blocks)) #:when (memf (curry char-ci=? word-char) b)) b))+  +  (define (inner word-chars blocks tried-blocks)+    (cond+      [(null? word-chars) #t]+      [(usable-block blocks (car word-chars))+       =>+       (lambda (b)+         (or+          (inner (cdr word-chars) (append tried-blocks (remove b blocks)) null)+          (inner word-chars (remove b blocks) (cons b tried-blocks))))]+      [else #f]))+  (inner (string->list w) BLOCKS null))++(define WORD-LIST '("" "A" "BARK" "BOOK" "TREAT" "COMMON" "SQUAD" "CONFUSE"))+(define (report-word w)+  (printf "Can we make: ~a? ~a~%"+          (~s w #:min-width 9)+          (if (can-make-word? w) "yes" "no")))++(module+ main+  (for-each report-word WORD-LIST))  ++(module+ test+  (require rackunit)+  (check-true  (can-make-word? ""))+  (check-true  (can-make-word? "A"))+  (check-true  (can-make-word? "BARK"))+  (check-false (can-make-word? "BOOK"))+  (check-true  (can-make-word? "TREAT"))+  (check-false (can-make-word? "COMMON"))+  (check-true  (can-make-word? "SQUAD"))+  (check-true  (can-make-word? "CONFUSE")))
+ test/cases/abc.tcl view
@@ -0,0 +1,21 @@+package require Tcl 8.6++proc abc {word {blocks {BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM}}} {+    set abc {{letters blocks abc} {+        set rest [lassign $letters ch]+        set i 0+        foreach blk $blocks {+            if {$ch in $blk && (![llength $rest]+                    || [apply $abc $rest [lreplace $blocks $i $i] $abc])} {+                return true+            }+            incr i+        }+        return false+    }}+    return [apply $abc [split $word ""] [lmap b $blocks {split $b ""}] $abc]+}++foreach word {"" A BARK BOOK TREAT COMMON SQUAD CONFUSE} {+    puts [format "Can we spell %9s? %s" '$word' [abc $word]]+}
+ test/cases/archive.rhtml view
@@ -0,0 +1,23 @@+<h1>Event Archive</h1>+++<% form_for :to_date, @to_date, :url => {:action => 'archive'} do |f| %>+  <p><label for="start_date">From</label>+  <%= select_date @from_date, :prefix => 'from' %>+  <label for="end_date">To</label>+  <%= select_date @to_date, :prefix => 'to', :start_year => 2000 %></p>+  <p><label for="event_series">Series</label>+  <%= select_tag "series", options_for_select(series_list('All'), @series) %>+  <%= f.submit 'Show events' %>+  </p>+<% end %>++<ul>+<%+if @events+%>+  <%= render :partial => 'events' %>+<%+end+%>+</ul>
+ test/cases/hk91.html view
@@ -0,0 +1,27 @@+<!DOCTYPE HTML>+<html>+<head>++  <script type="text/javascript">+    function makeHeaders(colnames) {+      var str = "";+      for (var i = 0; i < colnames.length; i++) {+        str += "<th>" + colnames[i] + "</th>";+      }+      return (str);+    }+  </script>++  <script>+    $(document).ready(function() {+      alert"hello");+    });+  </script>++</head>++<body>++</body>++</html>
+ test/cases/life.lua view
@@ -0,0 +1,111 @@+-- life.lua+-- original by Dave Bollinger <DBollinger@compuserve.com> posted to lua-l+-- modified to use ANSI terminal escape sequences+-- modified to use for instead of while++local write=io.write++ALIVE="¥"	DEAD="þ"+ALIVE="O"	DEAD="-"++function delay() -- NOTE: SYSTEM-DEPENDENT, adjust as necessary+  for i=1,10000 do end+  -- local i=os.clock()+1 while(os.clock()<i) do end+end++function ARRAY2D(w,h)+  local t = {w=w,h=h}+  for y=1,h do+    t[y] = {}+    for x=1,w do+      t[y][x]=0+    end+  end+  return t+end++_CELLS = {}++-- give birth to a "shape" within the cell array+function _CELLS:spawn(shape,left,top)+  for y=0,shape.h-1 do+    for x=0,shape.w-1 do+      self[top+y][left+x] = shape[y*shape.w+x+1]+    end+  end+end++-- run the CA and produce the next generation+function _CELLS:evolve(next)+  local ym1,y,yp1,yi=self.h-1,self.h,1,self.h+  while yi > 0 do+    local xm1,x,xp1,xi=self.w-1,self.w,1,self.w+    while xi > 0 do+      local sum = self[ym1][xm1] + self[ym1][x] + self[ym1][xp1] ++                  self[y][xm1] + self[y][xp1] ++                  self[yp1][xm1] + self[yp1][x] + self[yp1][xp1]+      next[y][x] = ((sum==2) and self[y][x]) or ((sum==3) and 1) or 0+      xm1,x,xp1,xi = x,xp1,xp1+1,xi-1+    end+    ym1,y,yp1,yi = y,yp1,yp1+1,yi-1+  end+end++-- output the array to screen+function _CELLS:draw()+  local out="" -- accumulate to reduce flicker+  for y=1,self.h do+   for x=1,self.w do+      out=out..(((self[y][x]>0) and ALIVE) or DEAD)+    end+    out=out.."\n"+  end+  write(out)+end++-- constructor+function CELLS(w,h)+  local c = ARRAY2D(w,h)+  c.spawn = _CELLS.spawn+  c.evolve = _CELLS.evolve+  c.draw = _CELLS.draw+  return c+end++--+-- shapes suitable for use with spawn() above+--+HEART = { 1,0,1,1,0,1,1,1,1; w=3,h=3 }+GLIDER = { 0,0,1,1,0,1,0,1,1; w=3,h=3 }+EXPLODE = { 0,1,0,1,1,1,1,0,1,0,1,0; w=3,h=4 }+FISH = { 0,1,1,1,1,1,0,0,0,1,0,0,0,0,1,1,0,0,1,0; w=5,h=4 }+BUTTERFLY = { 1,0,0,0,1,0,1,1,1,0,1,0,0,0,1,1,0,1,0,1,1,0,0,0,1; w=5,h=5 }++-- the main routine+function LIFE(w,h)+  -- create two arrays+  local thisgen = CELLS(w,h)+  local nextgen = CELLS(w,h)++  -- create some life+  -- about 1000 generations of fun, then a glider steady-state+  thisgen:spawn(GLIDER,5,4)+  thisgen:spawn(EXPLODE,25,10)+  thisgen:spawn(FISH,4,12)++  -- run until break+  local gen=1+  write("\027[2J")	-- ANSI clear screen+  while 1 do+    thisgen:evolve(nextgen)+    thisgen,nextgen = nextgen,thisgen+    write("\027[H")	-- ANSI home cursor+    thisgen:draw()+    write("Life - generation ",gen,"\n")+    gen=gen+1+    if gen>2000 then break end+    --delay()		-- no delay+  end+end++LIFE(40,20)
+ test/default.theme view
@@ -0,0 +1,177 @@+{+    "metadata" : {+        "revision" : 1,+        "name" : "Default",+        "author" : "Kate Authors",+        "license" : "MIT",+        "read-only" : true+    },+    "text-styles": {+        "Normal" : {+            "text-color" : "#1f1c1b",+            "selected-text-color" : "#ffffff",+            "bold" : false,+            "italic" : false,+            "underline" : false,+            "strike-through" : false+        },+        "Keyword" : {+            "text-color" : "#1f1c1b",+            "selected-text-color" : "#ffffff",+            "bold" : true+        },+        "Function" : {+            "text-color" : "#644a9b",+            "selected-text-color" : "#452886"+        },+        "Variable" : {+            "text-color" : "#0057ae",+            "selected-text-color" : "#00316e"+        },+        "ControlFlow" : {+            "text-color" : "#1f1c1b",+            "selected-text-color" : "#ffffff",+            "bold" : true+        },+        "Operator" : {+            "text-color" : "#1f1c1b",+            "selected-text-color" : "#ffffff"+        },+        "BuiltIn" : {+            "text-color" : "#644a9b",+            "selected-text-color" : "#452886",+            "bold" : true+        },+        "Extension" : {+            "text-color" : "#0095ff",+            "selected-text-color" : "#ffffff",+            "bold" : true+        },+        "Preprocessor" : {+            "text-color" : "#006e28",+            "selected-text-color" : "#006e28"+        },+        "Attribute" : {+            "text-color" : "#0057ae",+            "selected-text-color" : "#00316e"+        },+        "Char" : {+            "text-color" : "#924c9d",+            "selected-text-color" : "#6c2477"+        },+        "SpecialChar" : {+            "text-color" : "#3daee9",+            "selected-text-color" : "#fcfcfc"+        },+        "String" : {+            "text-color" : "#bf0303",+            "selected-text-color" : "#9c0e0e"+        },+        "VerbatimString" : {+            "text-color" : "#bf0303",+            "selected-text-color" : "#9c0e0e"+        },+        "SpecialString" : {+            "text-color" : "#ff5500",+            "selected-text-color" : "#ff5500"+        },+        "Import" : {+            "text-color" : "#ff5500",+            "selected-text-color" : "#ff5500"+        },+        "DataType" : {+            "text-color" : "#0057ae",+            "selected-text-color" : "#00316e"+        },+        "DecVal" : {+            "text-color" : "#b08000",+            "selected-text-color" : "#805c00"+        },+        "BaseN" : {+            "text-color" : "#b08000",+            "selected-text-color" : "#805c00"+        },+        "Float" : {+            "text-color" : "#b08000",+            "selected-text-color" : "#805c00"+        },+        "Constant" : {+            "text-color" : "#aa5500",+            "selected-text-color" : "#5e2f00"+        },+        "Comment" : {+            "text-color" : "#898887",+            "selected-text-color" : "#5e5d5d"+        },+        "Documentation" : {+            "text-color" : "#607880",+            "selected-text-color" : "#46585e"+        },+        "Annotation" : {+            "text-color" : "#ca60ca",+            "selected-text-color" : "#a44ea4"+        },+        "CommentVar" : {+            "text-color" : "#0095ff",+            "selected-text-color" : "#ffffff"+        },+        "RegionMarker" : {+            "text-color" : "#0057ae",+            "selected-text-color" : "#00316e",+            "background-color" : "#e0e9f8"+        },+        "Information" : {+            "text-color" : "#b08000",+            "selected-text-color" : "#805c00"+        },+        "Warning" : {+            "text-color" : "#bf0303",+            "selected-text-color" : "#9c0e0e"+        },+        "Alert" : {+            "text-color" : "#bf0303",+            "selected-text-color" : "#9c0e0e",+            "background-color" : "#f7e6e6",+            "bold" : true+        },+        "Error" : {+            "text-color" : "#bf0303",+            "selected-text-color" : "#9c0e0e",+            "underline" : true+        },+        "Others" : {+            "text-color" : "#006e28",+            "selected-text-color" : "#006e28"+        }+   },+    "editor-colors": {+        "background-color" : "#ffffff",+        "code-folding" : "#94caef",+        "bracket-matching" : "#ffff00",+        "current-line" : "#f8f7f6",+        "icon-border" : "#f0f0f0",+        "indentation-line" : "#d2d2d2",+        "line-numbers" : "#a0a0a0",+        "current-line-number" : "#1e1e1e",+        "mark-bookmark" : "#0000ff",+        "mark-breakpoint-active" : "#ff0000",+        "mark-breakpoint-reached" : "#ffff00",+        "mark-breakpoint-disabled" : "#ff00ff",+        "mark-execution" : "#a0a0a4",+        "mark-warning" : "#00ff00",+        "mark-error" : "#ff0000",+        "modified-lines" : "#fdbc4b",+        "replace-highlight" : "#00ff00",+        "saved-lines" : "#2ecc71",+        "search-highlight" : "#ffff00",+        "selection" : "#94caef",+        "separator" : "#898887",+        "spell-checking" : "#bf0303",+        "tab-marker" : "#d2d2d2",+        "template-background" : "#d6d2d0",+        "template-placeholder" : "#baf8ce",+        "template-focused-placeholder" : "#76da98",+        "template-read-only-placeholder" : "#f6e6e6",+        "word-wrap-marker" : "#ededed"+    }+}
+ test/expected/abc.ada.native view
@@ -0,0 +1,370 @@+[ [ ( KeywordTok , "with" )+  , ( NormalTok , " Ada.Characters.Handling;" )+  ]+, [ ( KeywordTok , "use" )+  , ( NormalTok , " Ada.Characters.Handling;" )+  ]+, []+, []+, [ ( KeywordTok , "package" )+  , ( NormalTok , " Abc " )+  , ( KeywordTok , "is" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "type" )+  , ( NormalTok , " Block_Faces " )+  , ( KeywordTok , "is" )+  , ( NormalTok , " " )+  , ( KeywordTok , "array" )+  , ( NormalTok , "(" )+  , ( DecValTok , "1" )+  , ( NormalTok , ".." )+  , ( DecValTok , "2" )+  , ( NormalTok , ") " )+  , ( KeywordTok , "of" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "Character" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "type" )+  , ( NormalTok , " Block_List " )+  , ( KeywordTok , "is" )+  , ( NormalTok , " " )+  , ( KeywordTok , "array" )+  , ( NormalTok , "(positive " )+  , ( KeywordTok , "range" )+  , ( NormalTok , " <>) " )+  , ( KeywordTok , "of" )+  , ( NormalTok , " Block_Faces;" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "function" )+  , ( NormalTok , " Can_Make_Word(W: " )+  , ( DataTypeTok , "String" )+  , ( NormalTok , "; Blocks: Block_List) " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "Boolean" )+  , ( NormalTok , ";" )+  ]+, [ ( KeywordTok , "end" ) , ( NormalTok , " Abc;" ) ]+, []+, []+, [ ( KeywordTok , "package" )+  , ( NormalTok , " " )+  , ( KeywordTok , "body" )+  , ( NormalTok , " Abc " )+  , ( KeywordTok , "is" )+  ]+, []+, [ ( KeywordTok , "function" )+  , ( NormalTok , " Can_Make_Word(W: " )+  , ( DataTypeTok , "String" )+  , ( NormalTok , "; Blocks: Block_List) " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "Boolean" )+  , ( NormalTok , " " )+  , ( KeywordTok , "is" )+  ]+, [ ( NormalTok , "    Used : " )+  , ( KeywordTok , "array" )+  , ( NormalTok , "(Blocks'Range) " )+  , ( KeywordTok , "of" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "Boolean" )+  , ( NormalTok , " := (" )+  , ( KeywordTok , "Others" )+  , ( NormalTok , " => False);" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "subtype" )+  , ( NormalTok , " wIndex " )+  , ( KeywordTok , "is" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "Integer" )+  , ( NormalTok , " " )+  , ( KeywordTok , "range" )+  , ( NormalTok , " W'First..W'Last;" )+  ]+, [ ( NormalTok , "    wPos : wIndex;" ) ]+, [ ( KeywordTok , "begin" ) ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " W'Length = " )+  , ( DecValTok , "0" )+  , ( NormalTok , " " )+  , ( KeywordTok , "then" )+  ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " True;" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "end if" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "    wPos := W'First;" ) ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "while" )+  , ( NormalTok , " True " )+  , ( KeywordTok , "loop" )+  ]+, [ ( NormalTok , "        " ) , ( KeywordTok , "declare" ) ]+, [ ( NormalTok , "            C : " )+  , ( DataTypeTok , "Character" )+  , ( NormalTok , " := To_Upper(W(wPos));" )+  ]+, [ ( NormalTok , "            X : " )+  , ( KeywordTok , "constant" )+  , ( NormalTok , " wIndex := wPos;" )+  ]+, [ ( NormalTok , "        " ) , ( KeywordTok , "begin" ) ]+, [ ( NormalTok , "            " )+  , ( KeywordTok , "for" )+  , ( NormalTok , " I " )+  , ( KeywordTok , "in" )+  , ( NormalTok , " Blocks'Range " )+  , ( KeywordTok , "loop" )+  ]+, [ ( NormalTok , "                " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " (" )+  , ( KeywordTok , "not" )+  , ( NormalTok , " Used(I)) " )+  , ( KeywordTok , "then" )+  ]+, [ ( NormalTok , "                    " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " C = To_Upper(Blocks(I)(" )+  , ( DecValTok , "1" )+  , ( NormalTok , ")) " )+  , ( KeywordTok , "or" )+  , ( NormalTok , " C = To_Upper(Blocks(I)(" )+  , ( DecValTok , "2" )+  , ( NormalTok , ")) " )+  , ( KeywordTok , "then" )+  ]+, [ ( NormalTok , "                        Used(I) := True;" ) ]+, [ ( NormalTok , "                        " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " wPos = W'Last " )+  , ( KeywordTok , "then" )+  ]+, [ ( NormalTok , "                            " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " True;" )+  ]+, [ ( NormalTok , "                        " )+  , ( KeywordTok , "end if" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok+    , "                        wPos := wIndex'Succ(wPos);"+    )+  ]+, [ ( NormalTok , "                        " )+  , ( KeywordTok , "exit" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "                    " )+  , ( KeywordTok , "end if" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "                " )+  , ( KeywordTok , "end if" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "            " )+  , ( KeywordTok , "end loop" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "            " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " X = wPos " )+  , ( KeywordTok , "then" )+  ]+, [ ( NormalTok , "                " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " False;" )+  ]+, [ ( NormalTok , "            " )+  , ( KeywordTok , "end if" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "end" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "end loop" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " False;" )+  ]+, [ ( KeywordTok , "end" ) , ( NormalTok , " Can_Make_Word;" ) ]+, []+, [ ( KeywordTok , "end" ) , ( NormalTok , " Abc;" ) ]+, []+, [ ( KeywordTok , "with" )+  , ( NormalTok , " Ada.Text_IO, Ada.Strings.Unbounded, Abc;" )+  ]+, [ ( KeywordTok , "use" )+  , ( NormalTok , " Ada.Text_IO, Ada.Strings.Unbounded, Abc;" )+  ]+, []+, [ ( KeywordTok , "procedure" )+  , ( NormalTok , " Abc_Problem " )+  , ( KeywordTok , "is" )+  ]+, [ ( NormalTok , "    Blocks : Block_List := (" ) ]+, [ ( NormalTok , "          (" )+  , ( CharTok , "'B'" )+  , ( NormalTok , "," )+  , ( CharTok , "'O'" )+  , ( NormalTok , "), (" )+  , ( CharTok , "'X'" )+  , ( NormalTok , "," )+  , ( CharTok , "'K'" )+  , ( NormalTok , "), (" )+  , ( CharTok , "'D'" )+  , ( NormalTok , "," )+  , ( CharTok , "'Q'" )+  , ( NormalTok , "), (" )+  , ( CharTok , "'C'" )+  , ( NormalTok , "," )+  , ( CharTok , "'P'" )+  , ( NormalTok , ")" )+  ]+, [ ( NormalTok , "        , (" )+  , ( CharTok , "'N'" )+  , ( NormalTok , "," )+  , ( CharTok , "'A'" )+  , ( NormalTok , "), (" )+  , ( CharTok , "'G'" )+  , ( NormalTok , "," )+  , ( CharTok , "'T'" )+  , ( NormalTok , "), (" )+  , ( CharTok , "'R'" )+  , ( NormalTok , "," )+  , ( CharTok , "'E'" )+  , ( NormalTok , "), (" )+  , ( CharTok , "'T'" )+  , ( NormalTok , "," )+  , ( CharTok , "'G'" )+  , ( NormalTok , ")" )+  ]+, [ ( NormalTok , "        , (" )+  , ( CharTok , "'Q'" )+  , ( NormalTok , "," )+  , ( CharTok , "'D'" )+  , ( NormalTok , "), (" )+  , ( CharTok , "'F'" )+  , ( NormalTok , "," )+  , ( CharTok , "'S'" )+  , ( NormalTok , "), (" )+  , ( CharTok , "'J'" )+  , ( NormalTok , "," )+  , ( CharTok , "'W'" )+  , ( NormalTok , "), (" )+  , ( CharTok , "'H'" )+  , ( NormalTok , "," )+  , ( CharTok , "'U'" )+  , ( NormalTok , ")" )+  ]+, [ ( NormalTok , "        , (" )+  , ( CharTok , "'V'" )+  , ( NormalTok , "," )+  , ( CharTok , "'I'" )+  , ( NormalTok , "), (" )+  , ( CharTok , "'A'" )+  , ( NormalTok , "," )+  , ( CharTok , "'N'" )+  , ( NormalTok , "), (" )+  , ( CharTok , "'O'" )+  , ( NormalTok , "," )+  , ( CharTok , "'B'" )+  , ( NormalTok , "), (" )+  , ( CharTok , "'E'" )+  , ( NormalTok , "," )+  , ( CharTok , "'R'" )+  , ( NormalTok , ")" )+  ]+, [ ( NormalTok , "        , (" )+  , ( CharTok , "'F'" )+  , ( NormalTok , "," )+  , ( CharTok , "'S'" )+  , ( NormalTok , "), (" )+  , ( CharTok , "'L'" )+  , ( NormalTok , "," )+  , ( CharTok , "'Y'" )+  , ( NormalTok , "), (" )+  , ( CharTok , "'P'" )+  , ( NormalTok , "," )+  , ( CharTok , "'C'" )+  , ( NormalTok , "), (" )+  , ( CharTok , "'Z'" )+  , ( NormalTok , "," )+  , ( CharTok , "'M'" )+  , ( NormalTok , ")" )+  ]+, [ ( NormalTok , "    );" ) ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "function" )+  , ( NormalTok , " " )+  , ( StringTok , "\"+\"" )+  , ( NormalTok , " (S : " )+  , ( DataTypeTok , "String" )+  , ( NormalTok , ") " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " Unbounded_String " )+  , ( KeywordTok , "renames" )+  , ( NormalTok , " To_Unbounded_String;" )+  ]+, [ ( NormalTok , "    words : " )+  , ( KeywordTok , "array" )+  , ( NormalTok , "(positive " )+  , ( KeywordTok , "range" )+  , ( NormalTok , " <>) " )+  , ( KeywordTok , "of" )+  , ( NormalTok , " Unbounded_String := (" )+  ]+, [ ( NormalTok , "          +" ) , ( StringTok , "\"A\"" ) ]+, [ ( NormalTok , "        , +" ) , ( StringTok , "\"BARK\"" ) ]+, [ ( NormalTok , "        , +" ) , ( StringTok , "\"BOOK\"" ) ]+, [ ( NormalTok , "        , +" ) , ( StringTok , "\"TREAT\"" ) ]+, [ ( NormalTok , "        , +" ) , ( StringTok , "\"COMMON\"" ) ]+, [ ( NormalTok , "        , +" ) , ( StringTok , "\"SQUAD\"" ) ]+, [ ( NormalTok , "        , +" ) , ( StringTok , "\"CONFUSE\"" ) ]+, [ ( NormalTok , "        " )+  , ( CommentTok , "-- Border cases:" )+  ]+, [ ( NormalTok , "        " )+  , ( CommentTok , "-- , +\"CONFUSE2\"" )+  ]+, [ ( NormalTok , "        " ) , ( CommentTok , "-- , +\"\"" ) ]+, [ ( NormalTok , "    );" ) ]+, [ ( KeywordTok , "begin" ) ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "for" )+  , ( NormalTok , " I " )+  , ( KeywordTok , "in" )+  , ( NormalTok , " words'Range " )+  , ( KeywordTok , "loop" )+  ]+, [ ( NormalTok , "        Put_Line ( To_String(words(I)) & " )+  , ( StringTok , "\": \"" )+  , ( NormalTok+    , " & Boolean'Image(Can_Make_Word(To_String(words(I)),Blocks)) );"+    )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "end loop" )+  , ( NormalTok , ";" )+  ]+, [ ( KeywordTok , "end" ) , ( NormalTok , " Abc_Problem;" ) ]+, []+]
+ test/expected/abc.agda.native view
@@ -0,0 +1,382 @@+[ [ ( KeywordTok , "module" )+  , ( NormalTok , " Reals " )+  , ( KeywordTok , "where" )+  ]+, []+, [ ( NormalTok , "  " )+  , ( CommentTok , "-- (a set with properties of) the reals" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "data" )+  , ( NormalTok , " \8477 " )+  , ( OtherTok , ":" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "Set" )+  , ( NormalTok , " " )+  , ( KeywordTok , "where" )+  ]+, [ ( NormalTok , "    r0 " )+  , ( OtherTok , ":" )+  , ( NormalTok , " \8477" )+  ]+, [ ( NormalTok , "    r1 " )+  , ( OtherTok , ":" )+  , ( NormalTok , " \8477" )+  ]+, [ ( NormalTok , "    " )+  , ( OtherTok , "_" )+  , ( NormalTok , "+" )+  , ( OtherTok , "_" )+  , ( NormalTok , " " )+  , ( OtherTok , ":" )+  , ( NormalTok , " \8477 " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " \8477 " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " \8477" )+  ]+, []+, [ ( NormalTok , "  " ) , ( CommentTok , "-- equality" ) ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "data" )+  , ( NormalTok , " " )+  , ( OtherTok , "_" )+  , ( NormalTok , "==" )+  , ( OtherTok , "_" )+  , ( NormalTok , " " )+  , ( OtherTok , ":" )+  , ( NormalTok , " \8477 " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " \8477 " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "Set" )+  , ( NormalTok , " " )+  , ( KeywordTok , "where" )+  ]+, [ ( NormalTok , "    AXrefl== " )+  , ( OtherTok , ":" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8704" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , "r" )+  , ( OtherTok , "}" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " r == r" )+  ]+, [ ( NormalTok , "    AXsymm== " )+  , ( OtherTok , ":" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8704" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , "r s" )+  , ( OtherTok , "}" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " r == s " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " s == r" )+  ]+, [ ( NormalTok , "    AXtrans== " )+  , ( OtherTok , ":" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8704" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , "r s t" )+  , ( OtherTok , "}" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " r == s " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " s == t " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " r == t" )+  ]+, [ ( NormalTok , "    AX+0 " )+  , ( OtherTok , ":" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8704" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , "r" )+  , ( OtherTok , "}" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " " )+  , ( OtherTok , "(" )+  , ( NormalTok , "r + r0" )+  , ( OtherTok , ")" )+  , ( NormalTok , " == r" )+  ]+, [ ( NormalTok , "    AXsymm+ " )+  , ( OtherTok , ":" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8704" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , "r s" )+  , ( OtherTok , "}" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " " )+  , ( OtherTok , "(" )+  , ( NormalTok , "r + s" )+  , ( OtherTok , ")" )+  , ( NormalTok , " == " )+  , ( OtherTok , "(" )+  , ( NormalTok , "s + r" )+  , ( OtherTok , ")" )+  ]+, [ ( NormalTok , "    AX+== " )+  , ( OtherTok , ":" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8704" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , "r s t" )+  , ( OtherTok , "}" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " r == s " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " " )+  , ( OtherTok , "(" )+  , ( NormalTok , "r + t" )+  , ( OtherTok , ")" )+  , ( NormalTok , " == " )+  , ( OtherTok , "(" )+  , ( NormalTok , "s + t" )+  , ( OtherTok , ")" )+  ]+, []+, [ ( NormalTok , "  THM0+ " )+  , ( OtherTok , ":" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , "r " )+  , ( OtherTok , ":" )+  , ( NormalTok , " \8477" )+  , ( OtherTok , "}" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " r == " )+  , ( OtherTok , "(" )+  , ( NormalTok , "r0 + r" )+  , ( OtherTok , ")" )+  ]+, [ ( NormalTok , "  THM0+ " )+  , ( OtherTok , "=" )+  , ( NormalTok , " AXsymm== " )+  , ( OtherTok , "(" )+  , ( NormalTok , "AXtrans== AXsymm+ AX+0" )+  , ( OtherTok , ")" )+  ]+, [ ( NormalTok , "  " )+  , ( CommentTok+    , "-- AXsymm+ AX+0   r0 + r == r + r0 and r + r0 == r"+    )+  ]+, [ ( NormalTok , "  " )+  , ( CommentTok , "-- AXtrans==      so r0 + r == r" )+  ]+, [ ( NormalTok , "  " )+  , ( CommentTok , "-- AXsymm==       so r == r0 + r" )+  ]+, []+, [ ( NormalTok , "  THM0+alt " )+  , ( OtherTok , ":" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , "r " )+  , ( OtherTok , ":" )+  , ( NormalTok , " \8477" )+  , ( OtherTok , "}" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " r == " )+  , ( OtherTok , "(" )+  , ( NormalTok , "r0 + r" )+  , ( OtherTok , ")" )+  ]+, [ ( NormalTok , "  THM0+alt " )+  , ( OtherTok , "{" )+  , ( NormalTok , "r" )+  , ( OtherTok , "}" )+  , ( NormalTok , " " )+  , ( OtherTok , "=" )+  , ( NormalTok , " AXsymm== " )+  , ( OtherTok , "{" )+  , ( NormalTok , "r0 + r" )+  , ( OtherTok , "}" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , "r" )+  , ( OtherTok , "}" )+  , ( NormalTok , " " )+  , ( OtherTok , "((" )+  , ( NormalTok , "AXtrans== " )+  , ( OtherTok , "{" )+  , ( NormalTok , "r0 + r" )+  , ( OtherTok , "}" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , "r + r0" )+  , ( OtherTok , "}" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , "r" )+  , ( OtherTok , "})" )+  , ( NormalTok , " " )+  , ( OtherTok , "(" )+  , ( NormalTok , "AXsymm+ " )+  , ( OtherTok , "{" )+  , ( NormalTok , "r0" )+  , ( OtherTok , "}" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , "r" )+  , ( OtherTok , "})" )+  , ( NormalTok , " " )+  , ( OtherTok , "(" )+  , ( NormalTok , "AX+0 " )+  , ( OtherTok , "{" )+  , ( NormalTok , "r" )+  , ( OtherTok , "}))" )+  ]+, []+, [ ( NormalTok , "  " )+  , ( CommentTok , "-- strict partial ordering" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "data" )+  , ( NormalTok , " " )+  , ( OtherTok , "_" )+  , ( NormalTok , "<" )+  , ( OtherTok , "_" )+  , ( NormalTok , " " )+  , ( OtherTok , ":" )+  , ( NormalTok , " \8477 " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " \8477 " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "Set" )+  , ( NormalTok , " " )+  , ( KeywordTok , "where" )+  ]+, [ ( NormalTok , "    AXtrans<<< " )+  , ( OtherTok , ":" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8704" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , "r s t" )+  , ( OtherTok , "}" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " r < s " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " s < t " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " r < t" )+  ]+, [ ( NormalTok , "    AX<=< " )+  , ( OtherTok , ":" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8704" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , "r s t" )+  , ( OtherTok , "}" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " r < s " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " s == t " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " r < t" )+  ]+, [ ( NormalTok , "    AX=<< " )+  , ( OtherTok , ":" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8704" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , "r s t" )+  , ( OtherTok , "}" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " r == s " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " s < t " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " r < t" )+  ]+, [ ( NormalTok , "    AX0<1 " )+  , ( OtherTok , ":" )+  , ( NormalTok , " r0 < r1" )+  ]+, [ ( NormalTok , "    AX+<< " )+  , ( OtherTok , ":" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8704" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , "r s t" )+  , ( OtherTok , "}" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " r < s " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " " )+  , ( OtherTok , "(" )+  , ( NormalTok , "r + t" )+  , ( OtherTok , ")" )+  , ( NormalTok , " < " )+  , ( OtherTok , "(" )+  , ( NormalTok , "s + t" )+  , ( OtherTok , ")" )+  ]+, []+, [ ( NormalTok , "  THM<+1 " )+  , ( OtherTok , ":" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , "r " )+  , ( OtherTok , ":" )+  , ( NormalTok , " \8477" )+  , ( OtherTok , "}" )+  , ( NormalTok , " " )+  , ( OtherTok , "\8594" )+  , ( NormalTok , " r < " )+  , ( OtherTok , "(" )+  , ( NormalTok , "r + r1" )+  , ( OtherTok , ")" )+  ]+, [ ( NormalTok , "  THM<+1 " )+  , ( OtherTok , "=" )+  , ( NormalTok , " AX<=< " )+  , ( OtherTok , "(" )+  , ( NormalTok , "AX=<< THM0+ " )+  , ( OtherTok , "(" )+  , ( NormalTok , "AX+<< AX0<1" )+  , ( OtherTok , "))" )+  , ( NormalTok , " AXsymm+" )+  ]+, [ ( NormalTok , "  " )+  , ( CommentTok , "-- AX0<1              0 < 1" )+  ]+, [ ( NormalTok , "  " )+  , ( CommentTok , "-- AX<+ %             so 0 + r < 1 + r" )+  ]+, [ ( NormalTok , "  " )+  , ( CommentTok , "-- AX=<< lem0+ %      so r < 1 + r" )+  ]+, [ ( NormalTok , "  " )+  , ( CommentTok , "-- AX<=< % AXsymm+    so r < r + 1" )+  ]+]
+ test/expected/abc.c.native view
@@ -0,0 +1,197 @@+[ [ ( PreprocessorTok , "#include " )+  , ( ImportTok , "<stdio.h>" )+  ]+, [ ( PreprocessorTok , "#include " )+  , ( ImportTok , "<ctype.h>" )+  ]+, []+, [ ( DataTypeTok , "int" )+  , ( NormalTok , " can_make_words(" )+  , ( DataTypeTok , "char" )+  , ( NormalTok , " **b, " )+  , ( DataTypeTok , "char" )+  , ( NormalTok , " *word)" )+  ]+, [ ( NormalTok , "{" ) ]+, [ ( NormalTok , "        " )+  , ( DataTypeTok , "int" )+  , ( NormalTok , " i, ret = " )+  , ( DecValTok , "0" )+  , ( NormalTok , ", c = toupper(*word);" )+  ]+, []+, [ ( PreprocessorTok+    , "#define SWAP(a, b) if (a != b) { char * tmp = a; a = b; b = tmp; }"+    )+  ]+, []+, [ ( NormalTok , "        " )+  , ( ControlFlowTok , "if" )+  , ( NormalTok , " (!c) " )+  , ( ControlFlowTok , "return" )+  , ( NormalTok , " " )+  , ( DecValTok , "1" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "        " )+  , ( ControlFlowTok , "if" )+  , ( NormalTok , " (!b[" )+  , ( DecValTok , "0" )+  , ( NormalTok , "]) " )+  , ( ControlFlowTok , "return" )+  , ( NormalTok , " " )+  , ( DecValTok , "0" )+  , ( NormalTok , ";" )+  ]+, []+, [ ( NormalTok , "        " )+  , ( ControlFlowTok , "for" )+  , ( NormalTok , " (i = " )+  , ( DecValTok , "0" )+  , ( NormalTok , "; b[i] && !ret; i++) {" )+  ]+, [ ( NormalTok , "                " )+  , ( ControlFlowTok , "if" )+  , ( NormalTok , " (b[i][" )+  , ( DecValTok , "0" )+  , ( NormalTok , "] != c && b[i][" )+  , ( DecValTok , "1" )+  , ( NormalTok , "] != c) " )+  , ( ControlFlowTok , "continue" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "                SWAP(b[i], b[" )+  , ( DecValTok , "0" )+  , ( NormalTok , "]);" )+  ]+, [ ( NormalTok , "                ret = can_make_words(b + " )+  , ( DecValTok , "1" )+  , ( NormalTok , ", word + " )+  , ( DecValTok , "1" )+  , ( NormalTok , ");" )+  ]+, [ ( NormalTok , "                SWAP(b[i], b[" )+  , ( DecValTok , "0" )+  , ( NormalTok , "]);" )+  ]+, [ ( NormalTok , "        }" ) ]+, []+, [ ( NormalTok , "        " )+  , ( ControlFlowTok , "return" )+  , ( NormalTok , " ret;" )+  ]+, [ ( NormalTok , "}" ) ]+, []+, [ ( DataTypeTok , "int" )+  , ( NormalTok , " main(" )+  , ( DataTypeTok , "void" )+  , ( NormalTok , ")" )+  ]+, [ ( NormalTok , "{" ) ]+, [ ( NormalTok , "        " )+  , ( DataTypeTok , "char" )+  , ( NormalTok , "* blocks[] = {" )+  ]+, [ ( NormalTok , "                " )+  , ( StringTok , "\"BO\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"XK\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"DQ\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"CP\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"NA\"" )+  , ( NormalTok , ", " )+  ]+, [ ( NormalTok , "                " )+  , ( StringTok , "\"GT\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"RE\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"TG\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"QD\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"FS\"" )+  , ( NormalTok , ", " )+  ]+, [ ( NormalTok , "                " )+  , ( StringTok , "\"JW\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"HU\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"VI\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"AN\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"OB\"" )+  , ( NormalTok , ", " )+  ]+, [ ( NormalTok , "                " )+  , ( StringTok , "\"ER\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"FS\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"LY\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"PC\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"ZM\"" )+  , ( NormalTok , "," )+  ]+, [ ( NormalTok , "                " )+  , ( DecValTok , "0" )+  , ( NormalTok , " };" )+  ]+, []+, [ ( NormalTok , "        " )+  , ( DataTypeTok , "char" )+  , ( NormalTok , " *words[] = {" )+  ]+, [ ( NormalTok , "                " )+  , ( StringTok , "\"\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"A\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"BARK\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"BOOK\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"TREAT\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"COMMON\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"SQUAD\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"Confuse\"" )+  , ( NormalTok , ", " )+  , ( DecValTok , "0" )+  ]+, [ ( NormalTok , "        };" ) ]+, []+, [ ( NormalTok , "        " )+  , ( DataTypeTok , "char" )+  , ( NormalTok , " **w;" )+  ]+, [ ( NormalTok , "        " )+  , ( ControlFlowTok , "for" )+  , ( NormalTok , " (w = words; *w; w++)" )+  ]+, [ ( NormalTok , "                printf(" )+  , ( StringTok , "\"%s" )+  , ( SpecialCharTok , "\\t" )+  , ( StringTok , "%d" )+  , ( SpecialCharTok , "\\n" )+  , ( StringTok , "\"" )+  , ( NormalTok , ", *w, can_make_words(blocks, *w));" )+  ]+, []+, [ ( NormalTok , "        " )+  , ( ControlFlowTok , "return" )+  , ( NormalTok , " " )+  , ( DecValTok , "0" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "}" ) ]+]
+ test/expected/abc.clojure.native view
@@ -0,0 +1,101 @@+[ []+, [ ( NormalTok , "(" )+  , ( BuiltInTok , "def" )+  , ( FunctionTok , " blocks" )+  ]+, [ ( NormalTok , "  (" )+  , ( KeywordTok , "->" )+  , ( NormalTok , " " )+  , ( StringTok+    , "\"BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM\""+    )+  , ( NormalTok , " (.split " )+  , ( StringTok , "\" \"" )+  , ( NormalTok , ") " )+  , ( KeywordTok , "vec" )+  , ( NormalTok , "))" )+  ]+, []+, [ ( NormalTok , "(" )+  , ( BuiltInTok , "defn" )+  , ( FunctionTok , " omit " )+  ]+, [ ( NormalTok , "  " )+  , ( StringTok , "\"return bs with (one instance of) b omitted\"" )+  ]+, [ ( NormalTok , "  [bs b] " ) ]+, [ ( NormalTok , "  (" )+  , ( KeywordTok , "let" )+  , ( NormalTok , " [[before after] (" )+  , ( KeywordTok , "split-with" )+  , ( NormalTok , " #(" )+  , ( KeywordTok , "not=" )+  , ( NormalTok , " b %) bs)]" )+  ]+, [ ( NormalTok , "    (" )+  , ( KeywordTok , "concat" )+  , ( NormalTok , " before (" )+  , ( KeywordTok , "rest" )+  , ( NormalTok , " after))))" )+  ]+, []+, [ ( NormalTok , "(" )+  , ( BuiltInTok , "defn" )+  , ( FunctionTok , " abc " )+  ]+, [ ( NormalTok , "  " )+  , ( StringTok+    , "\"return lazy sequence of solutions (i.e. block lists)\""+    )+  ]+, [ ( NormalTok , "  [blocks [c & cs]]" ) ]+, [ ( NormalTok , "  (if-some c" ) ]+, [ ( NormalTok , "    (" )+  , ( KeywordTok , "for" )+  , ( NormalTok , " [b blocks " )+  , ( AttributeTok , ":when" )+  , ( NormalTok , " (" )+  , ( KeywordTok , "some" )+  , ( NormalTok , " #(" )+  , ( KeywordTok , "=" )+  , ( NormalTok , " c %) b)" )+  ]+, [ ( NormalTok , "          bs (abc (omit blocks b) cs)]" ) ]+, [ ( NormalTok , "      (" )+  , ( KeywordTok , "cons" )+  , ( NormalTok , " b bs))" )+  ]+, [ ( NormalTok , "    [[]]))" ) ]+, [ ( NormalTok , "    " ) ]+, [ ( NormalTok , "      " ) ]+, [ ( NormalTok , "(" )+  , ( KeywordTok , "doseq" )+  , ( NormalTok , " [word [" )+  , ( StringTok , "\"A\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"BARK\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"Book\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"treat\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"COMMON\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"SQUAD\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"CONFUSE\"" )+  , ( NormalTok , "]]" )+  ]+, [ ( NormalTok , "  (" )+  , ( KeywordTok , "->>" )+  , ( NormalTok , " word .toUpperCase (abc blocks) " )+  , ( KeywordTok , "first" )+  , ( NormalTok , " (" )+  , ( KeywordTok , "printf" )+  , ( NormalTok , " " )+  , ( StringTok , "\"%s: %b" )+  , ( NormalTok , "\\n" )+  , ( StringTok , "\"" )+  , ( NormalTok , " word)))" )+  ]+]
+ test/expected/abc.cpp.native view
@@ -0,0 +1,236 @@+[ [ ( PreprocessorTok , "#include " )+  , ( ImportTok , "<iostream>" )+  ]+, [ ( PreprocessorTok , "#include " )+  , ( ImportTok , "<vector>" )+  ]+, [ ( PreprocessorTok , "#include " )+  , ( ImportTok , "<string>" )+  ]+, [ ( PreprocessorTok , "#include " ) , ( ImportTok , "<set>" ) ]+, [ ( PreprocessorTok , "#include " )+  , ( ImportTok , "<cctype>" )+  ]+, []+, []+, [ ( KeywordTok , "typedef" )+  , ( NormalTok , " " )+  , ( BuiltInTok , "std::" )+  , ( NormalTok , "pair<" )+  , ( DataTypeTok , "char" )+  , ( NormalTok , "," )+  , ( DataTypeTok , "char" )+  , ( NormalTok , "> " )+  , ( DataTypeTok , "item_t" )+  , ( NormalTok , ";" )+  ]+, [ ( KeywordTok , "typedef" )+  , ( NormalTok , " " )+  , ( BuiltInTok , "std::" )+  , ( NormalTok , "vector<" )+  , ( DataTypeTok , "item_t" )+  , ( NormalTok , "> " )+  , ( DataTypeTok , "list_t" )+  , ( NormalTok , ";" )+  ]+, []+, [ ( DataTypeTok , "bool" )+  , ( NormalTok , " can_make_word(" )+  , ( AttributeTok , "const" )+  , ( NormalTok , " " )+  , ( BuiltInTok , "std::" )+  , ( NormalTok , "string& w, " )+  , ( AttributeTok , "const" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "list_t" )+  , ( NormalTok , "& vals) {" )+  ]+, [ ( NormalTok , "    " )+  , ( BuiltInTok , "std::" )+  , ( NormalTok , "set<" )+  , ( DataTypeTok , "uint32_t" )+  , ( NormalTok , "> used;" )+  ]+, [ ( NormalTok , "    " )+  , ( ControlFlowTok , "while" )+  , ( NormalTok , " (used.size() < w.size()) {" )+  ]+, [ ( NormalTok , "        " )+  , ( AttributeTok , "const" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "char" )+  , ( NormalTok , " c = toupper(w[used.size()]);" )+  ]+, [ ( NormalTok , "        " )+  , ( DataTypeTok , "uint32_t" )+  , ( NormalTok , " x = used.size();" )+  ]+, [ ( NormalTok , "        " )+  , ( ControlFlowTok , "for" )+  , ( NormalTok , " (" )+  , ( DataTypeTok , "uint32_t" )+  , ( NormalTok , " i = " )+  , ( DecValTok , "0" )+  , ( NormalTok , ", ii = vals.size(); i < ii; ++i) {" )+  ]+, [ ( NormalTok , "            " )+  , ( ControlFlowTok , "if" )+  , ( NormalTok , " (used.find(i) == used.end()) {" )+  ]+, [ ( NormalTok , "                " )+  , ( ControlFlowTok , "if" )+  , ( NormalTok+    , " (toupper(vals[i].first) == c || toupper(vals[i].second) == c) {"+    )+  ]+, [ ( NormalTok , "                    used.insert(i);" ) ]+, [ ( NormalTok , "                    " )+  , ( ControlFlowTok , "break" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "                }" ) ]+, [ ( NormalTok , "            }" ) ]+, [ ( NormalTok , "        }" ) ]+, [ ( NormalTok , "        " )+  , ( ControlFlowTok , "if" )+  , ( NormalTok , " (x == used.size()) " )+  , ( ControlFlowTok , "break" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "    }" ) ]+, [ ( NormalTok , "    " )+  , ( ControlFlowTok , "return" )+  , ( NormalTok , " used.size() == w.size();" )+  ]+, [ ( NormalTok , "}" ) ]+, []+, []+, [ ( DataTypeTok , "int" ) , ( NormalTok , " main() {" ) ]+, [ ( NormalTok , "    " )+  , ( DataTypeTok , "list_t" )+  , ( NormalTok , " vals{ {" )+  , ( StringTok , "'B'" )+  , ( NormalTok , "," )+  , ( StringTok , "'O'" )+  , ( NormalTok , "}, {" )+  , ( StringTok , "'X'" )+  , ( NormalTok , "," )+  , ( StringTok , "'K'" )+  , ( NormalTok , "}, {" )+  , ( StringTok , "'D'" )+  , ( NormalTok , "," )+  , ( StringTok , "'Q'" )+  , ( NormalTok , "}, {" )+  , ( StringTok , "'C'" )+  , ( NormalTok , "," )+  , ( StringTok , "'P'" )+  , ( NormalTok , "}, {" )+  , ( StringTok , "'N'" )+  , ( NormalTok , "," )+  , ( StringTok , "'A'" )+  , ( NormalTok , "}, {" )+  , ( StringTok , "'G'" )+  , ( NormalTok , "," )+  , ( StringTok , "'T'" )+  , ( NormalTok , "}, {" )+  , ( StringTok , "'R'" )+  , ( NormalTok , "," )+  , ( StringTok , "'E'" )+  , ( NormalTok , "}, {" )+  , ( StringTok , "'T'" )+  , ( NormalTok , "," )+  , ( StringTok , "'G'" )+  , ( NormalTok , "}, {" )+  , ( StringTok , "'Q'" )+  , ( NormalTok , "," )+  , ( StringTok , "'D'" )+  , ( NormalTok , "}, {" )+  , ( StringTok , "'F'" )+  , ( NormalTok , "," )+  , ( StringTok , "'S'" )+  , ( NormalTok , "}, {" )+  , ( StringTok , "'J'" )+  , ( NormalTok , "," )+  , ( StringTok , "'W'" )+  , ( NormalTok , "}, {" )+  , ( StringTok , "'H'" )+  , ( NormalTok , "," )+  , ( StringTok , "'U'" )+  , ( NormalTok , "}, {" )+  , ( StringTok , "'V'" )+  , ( NormalTok , "," )+  , ( StringTok , "'I'" )+  , ( NormalTok , "}, {" )+  , ( StringTok , "'A'" )+  , ( NormalTok , "," )+  , ( StringTok , "'N'" )+  , ( NormalTok , "}, {" )+  , ( StringTok , "'O'" )+  , ( NormalTok , "," )+  , ( StringTok , "'B'" )+  , ( NormalTok , "}, {" )+  , ( StringTok , "'E'" )+  , ( NormalTok , "," )+  , ( StringTok , "'R'" )+  , ( NormalTok , "}, {" )+  , ( StringTok , "'F'" )+  , ( NormalTok , "," )+  , ( StringTok , "'S'" )+  , ( NormalTok , "}, {" )+  , ( StringTok , "'L'" )+  , ( NormalTok , "," )+  , ( StringTok , "'Y'" )+  , ( NormalTok , "}, {" )+  , ( StringTok , "'P'" )+  , ( NormalTok , "," )+  , ( StringTok , "'C'" )+  , ( NormalTok , "}, {" )+  , ( StringTok , "'Z'" )+  , ( NormalTok , "," )+  , ( StringTok , "'M'" )+  , ( NormalTok , "} };" )+  ]+, [ ( NormalTok , "    " )+  , ( BuiltInTok , "std::" )+  , ( NormalTok , "vector<" )+  , ( BuiltInTok , "std::" )+  , ( NormalTok , "string> words{" )+  , ( StringTok , "\"A\"" )+  , ( NormalTok , "," )+  , ( StringTok , "\"BARK\"" )+  , ( NormalTok , "," )+  , ( StringTok , "\"BOOK\"" )+  , ( NormalTok , "," )+  , ( StringTok , "\"TREAT\"" )+  , ( NormalTok , "," )+  , ( StringTok , "\"COMMON\"" )+  , ( NormalTok , "," )+  , ( StringTok , "\"SQUAD\"" )+  , ( NormalTok , "," )+  , ( StringTok , "\"CONFUSE\"" )+  , ( NormalTok , "};" )+  ]+, [ ( NormalTok , "    " )+  , ( ControlFlowTok , "for" )+  , ( NormalTok , " (" )+  , ( AttributeTok , "const" )+  , ( NormalTok , " " )+  , ( BuiltInTok , "std::" )+  , ( NormalTok , "string& w : words) {" )+  ]+, [ ( NormalTok , "        " )+  , ( BuiltInTok , "std::" )+  , ( NormalTok , "cout << w << " )+  , ( StringTok , "\": \"" )+  , ( NormalTok , " << " )+  , ( BuiltInTok , "std::" )+  , ( NormalTok , "boolalpha << can_make_word(w,vals) << " )+  , ( StringTok , "\"." )+  , ( SpecialCharTok , "\\n" )+  , ( StringTok , "\"" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "    }" ) ]+, []+, [ ( NormalTok , "}" ) ]+]
+ test/expected/abc.cs.native view
@@ -0,0 +1,362 @@+[ [ ( KeywordTok , "using" )+  , ( NormalTok , " System." )+  , ( FunctionTok , "Collections" )+  , ( NormalTok , "." )+  , ( FunctionTok , "Generic" )+  , ( NormalTok , ";" )+  ]+, [ ( KeywordTok , "using" )+  , ( NormalTok , " System." )+  , ( FunctionTok , "Linq" )+  , ( NormalTok , ";" )+  ]+, []+, [ ( DataTypeTok , "void" )+  , ( NormalTok , " " )+  , ( FunctionTok , "Main" )+  , ( NormalTok , "()" )+  ]+, [ ( NormalTok , "{" ) ]+, [ ( NormalTok , "        List<" )+  , ( DataTypeTok , "string" )+  , ( NormalTok , "> blocks =" )+  ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "new" )+  , ( NormalTok , " List<" )+  , ( DataTypeTok , "string" )+  , ( NormalTok , ">() { " )+  , ( StringTok , "\"bo\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"xk\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"dq\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"cp\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"na\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"gt\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"re\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"tg\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"qd\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"fs\"" )+  , ( NormalTok , "," )+  ]+, [ ( NormalTok , "                " )+  , ( StringTok , "\"jw\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"hu\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"vi\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"an\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"ob\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"er\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"fs\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"ly\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"pc\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"zm\"" )+  , ( NormalTok , " };" )+  ]+, [ ( NormalTok , "        List<" )+  , ( DataTypeTok , "string" )+  , ( NormalTok , "> words = " )+  , ( KeywordTok , "new" )+  , ( NormalTok , " List<" )+  , ( DataTypeTok , "string" )+  , ( NormalTok , ">() {" )+  ]+, [ ( NormalTok , "                " )+  , ( StringTok , "\"A\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"BARK\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"BOOK\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"TREAT\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"COMMON\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"SQUAD\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"CONFUSE\"" )+  , ( NormalTok , "};" )+  ]+, [ ( NormalTok , "        " ) ]+, [ ( NormalTok , "        " )+  , ( DataTypeTok , "var" )+  , ( NormalTok , " solver = " )+  , ( KeywordTok , "new" )+  , ( NormalTok , " " )+  , ( FunctionTok , "ABC" )+  , ( NormalTok , "(blocks);" )+  ]+, [ ( NormalTok , "        " ) ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "foreach" )+  , ( NormalTok , "( var word " )+  , ( KeywordTok , "in" )+  , ( NormalTok , " words)" )+  ]+, [ ( NormalTok , "        {" ) ]+, [ ( NormalTok , "                Console." )+  , ( FunctionTok , "WriteLine" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"{0} :{1}\"" )+  , ( NormalTok , ", word, solver." )+  , ( FunctionTok , "CanMake" )+  , ( NormalTok , "(word));" )+  ]+, [ ( NormalTok , "        }" ) ]+, [ ( NormalTok , "}" ) ]+, []+, [ ( KeywordTok , "class" ) , ( NormalTok , " ABC" ) ]+, [ ( NormalTok , "{" ) ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "readonly" )+  , ( NormalTok , " Dictionary<" )+  , ( DataTypeTok , "char" )+  , ( NormalTok , ", List<" )+  , ( DataTypeTok , "int" )+  , ( NormalTok , ">> _blockDict = " )+  , ( KeywordTok , "new" )+  , ( NormalTok , " Dictionary<" )+  , ( DataTypeTok , "char" )+  , ( NormalTok , ", List<" )+  , ( DataTypeTok , "int" )+  , ( NormalTok , ">>();" )+  ]+, [ ( NormalTok , "        " )+  , ( DataTypeTok , "bool" )+  , ( NormalTok , "[] _used;" )+  ]+, [ ( NormalTok , "        " )+  , ( DataTypeTok , "int" )+  , ( NormalTok , " _nextBlock;" )+  ]+, []+, [ ( NormalTok , "        " )+  , ( KeywordTok , "readonly" )+  , ( NormalTok , " List<" )+  , ( DataTypeTok , "string" )+  , ( NormalTok , "> _blocks;" )+  ]+, []+, [ ( NormalTok , "        " )+  , ( KeywordTok , "private" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "void" )+  , ( NormalTok , " " )+  , ( FunctionTok , "AddBlockChar" )+  , ( NormalTok , "(" )+  , ( DataTypeTok , "char" )+  , ( NormalTok , " c)" )+  ]+, [ ( NormalTok , "        {" ) ]+, [ ( NormalTok , "                " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " (!_blockDict." )+  , ( FunctionTok , "ContainsKey" )+  , ( NormalTok , "(c))" )+  ]+, [ ( NormalTok , "                {" ) ]+, [ ( NormalTok , "                        _blockDict[c] = " )+  , ( KeywordTok , "new" )+  , ( NormalTok , " List<" )+  , ( DataTypeTok , "int" )+  , ( NormalTok , ">();" )+  ]+, [ ( NormalTok , "                }" ) ]+, [ ( NormalTok , "                _blockDict[c]." )+  , ( FunctionTok , "Add" )+  , ( NormalTok , "(_nextBlock);" )+  ]+, [ ( NormalTok , "        }" ) ]+, []+, [ ( NormalTok , "        " )+  , ( KeywordTok , "private" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "void" )+  , ( NormalTok , " " )+  , ( FunctionTok , "AddBlock" )+  , ( NormalTok , "(" )+  , ( DataTypeTok , "string" )+  , ( NormalTok , " block)" )+  ]+, [ ( NormalTok , "        {" ) ]+, [ ( NormalTok , "                " )+  , ( FunctionTok , "AddBlockChar" )+  , ( NormalTok , "(block[" )+  , ( DecValTok , "0" )+  , ( NormalTok , "]);" )+  ]+, [ ( NormalTok , "                " )+  , ( FunctionTok , "AddBlockChar" )+  , ( NormalTok , "(block[" )+  , ( DecValTok , "1" )+  , ( NormalTok , "]);" )+  ]+, [ ( NormalTok , "                _nextBlock++;" ) ]+, [ ( NormalTok , "        }" ) ]+, []+, [ ( NormalTok , "        " )+  , ( KeywordTok , "public" )+  , ( NormalTok , " " )+  , ( FunctionTok , "ABC" )+  , ( NormalTok , "(List<" )+  , ( DataTypeTok , "string" )+  , ( NormalTok , "> blocks)" )+  ]+, [ ( NormalTok , "        {" ) ]+, [ ( NormalTok , "                _blocks = blocks;" ) ]+, [ ( NormalTok , "                " )+  , ( KeywordTok , "foreach" )+  , ( NormalTok , " (var block " )+  , ( KeywordTok , "in" )+  , ( NormalTok , " blocks)" )+  ]+, [ ( NormalTok , "                {" ) ]+, [ ( NormalTok , "                        " )+  , ( FunctionTok , "AddBlock" )+  , ( NormalTok , "(block);" )+  ]+, [ ( NormalTok , "                }" ) ]+, [ ( NormalTok , "        }" ) ]+, []+, [ ( NormalTok , "        " )+  , ( KeywordTok , "public" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "bool" )+  , ( NormalTok , " " )+  , ( FunctionTok , "CanMake" )+  , ( NormalTok , "(" )+  , ( DataTypeTok , "string" )+  , ( NormalTok , " word)" )+  ]+, [ ( NormalTok , "        {" ) ]+, [ ( NormalTok , "                word = word." )+  , ( FunctionTok , "ToLower" )+  , ( NormalTok , "();" )+  ]+, [ ( NormalTok , "                " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " (word." )+  , ( FunctionTok , "Length" )+  , ( NormalTok , " > _blockDict." )+  , ( FunctionTok , "Count" )+  , ( NormalTok , ")" )+  ]+, [ ( NormalTok , "                {" ) ]+, [ ( NormalTok , "                        " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( KeywordTok , "false" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "                }" ) ]+, [ ( NormalTok , "                _used = " )+  , ( KeywordTok , "new" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "bool" )+  , ( NormalTok , "[_blocks." )+  , ( FunctionTok , "Count" )+  , ( NormalTok , "];" )+  ]+, [ ( NormalTok , "                " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( FunctionTok , "TryMake" )+  , ( NormalTok , "(word);" )+  ]+, [ ( NormalTok , "        }" ) ]+, []+, [ ( NormalTok , "        " )+  , ( KeywordTok , "public" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "bool" )+  , ( NormalTok , " " )+  , ( FunctionTok , "TryMake" )+  , ( NormalTok , "(" )+  , ( DataTypeTok , "string" )+  , ( NormalTok , " word)" )+  ]+, [ ( NormalTok , "        {" ) ]+, [ ( NormalTok , "                " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " (word == " )+  , ( DataTypeTok , "string" )+  , ( NormalTok , "." )+  , ( FunctionTok , "Empty" )+  , ( NormalTok , ")" )+  ]+, [ ( NormalTok , "                {" ) ]+, [ ( NormalTok , "                        " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( KeywordTok , "true" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "                }" ) ]+, [ ( NormalTok , "                " )+  , ( DataTypeTok , "var" )+  , ( NormalTok , " blocks = _blockDict[word[" )+  , ( DecValTok , "0" )+  , ( NormalTok , "]]." )+  , ( FunctionTok , "Where" )+  , ( NormalTok , "(b => !_used[b]);" )+  ]+, [ ( NormalTok , "                " )+  , ( KeywordTok , "foreach" )+  , ( NormalTok , " (var block " )+  , ( KeywordTok , "in" )+  , ( NormalTok , " blocks)" )+  ]+, [ ( NormalTok , "                {" ) ]+, [ ( NormalTok , "                        _used[block] = " )+  , ( KeywordTok , "true" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "                        " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " (" )+  , ( FunctionTok , "TryMake" )+  , ( NormalTok , "(word." )+  , ( FunctionTok , "Substring" )+  , ( NormalTok , "(" )+  , ( DecValTok , "1" )+  , ( NormalTok , ")))" )+  ]+, [ ( NormalTok , "                        {" ) ]+, [ ( NormalTok , "                                " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( KeywordTok , "true" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "                        }" ) ]+, [ ( NormalTok , "                        _used[block] = " )+  , ( KeywordTok , "false" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "                }" ) ]+, [ ( NormalTok , "                " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( KeywordTok , "false" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "        }" ) ]+, [ ( NormalTok , "}" ) ]+, []+]
+ test/expected/abc.d.native view
@@ -0,0 +1,180 @@+[ [ ( KeywordTok , "import" )+  , ( NormalTok+    , " std.stdio, std.ascii, std.algorithm, std.array, std.range;"+    )+  ]+, []+, [ ( KeywordTok , "alias" )+  , ( NormalTok , " Block = " )+  , ( DataTypeTok , "char" )+  , ( NormalTok , "[" )+  , ( DecValTok , "2" )+  , ( NormalTok , "];" )+  ]+, []+, [ ( DataTypeTok , "bool" )+  , ( NormalTok , " canMakeWord(" )+  , ( KeywordTok , "immutable" )+  , ( NormalTok , " Block[] blocks, " )+  , ( KeywordTok , "in" )+  , ( NormalTok , " " )+  , ( BuiltInTok , "string" )+  , ( NormalTok , " word) " )+  , ( KeywordTok , "pure" )+  , ( NormalTok , " " )+  , ( KeywordTok , "nothrow" )+  ]+, [ ( KeywordTok , "in " ) , ( NormalTok , "{" ) ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "assert" )+  , ( NormalTok , "(blocks.all!(w => w[].all!isAlpha));" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "assert" )+  , ( NormalTok , "(word.all!isAlpha);" )+  ]+, [ ( NormalTok , "} " )+  , ( KeywordTok , "body" )+  , ( NormalTok , " {" )+  ]+, [ ( NormalTok , "    " )+  , ( DataTypeTok , "bool" )+  , ( NormalTok , " inner(" )+  , ( BuiltInTok , "size_t" )+  , ( NormalTok , "[] indexes, " )+  , ( KeywordTok , "in" )+  , ( NormalTok , " " )+  , ( BuiltInTok , "string" )+  , ( NormalTok , " w) " )+  , ( KeywordTok , "pure" )+  , ( NormalTok , " " )+  , ( KeywordTok , "nothrow" )+  , ( NormalTok , " {" )+  ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " (w.empty)" )+  ]+, [ ( NormalTok , "            " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( KeywordTok , "true" )+  , ( NormalTok , ";" )+  ]+, []+, [ ( NormalTok , "        " )+  , ( KeywordTok , "immutable" )+  , ( NormalTok , " c = w[" )+  , ( DecValTok , "0" )+  , ( NormalTok , "].toUpper;" )+  ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "foreach" )+  , ( NormalTok , " (" )+  , ( KeywordTok , "ref" )+  , ( NormalTok , " idx; indexes) {" )+  ]+, [ ( NormalTok , "            " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " (blocks[idx][" )+  , ( DecValTok , "0" )+  , ( NormalTok , "].toUpper != c &&" )+  ]+, [ ( NormalTok , "                blocks[idx][" )+  , ( DecValTok , "1" )+  , ( NormalTok , "].toUpper != c)" )+  ]+, [ ( NormalTok , "                " )+  , ( KeywordTok , "continue" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "            indexes[" )+  , ( DecValTok , "0" )+  , ( NormalTok , "].swap(idx);" )+  ]+, [ ( NormalTok , "            " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " (inner(indexes[" )+  , ( DecValTok , "1" )+  , ( NormalTok , " .. $], w[" )+  , ( DecValTok , "1" )+  , ( NormalTok , " .. $]))" )+  ]+, [ ( NormalTok , "                " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( KeywordTok , "true" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "            indexes[" )+  , ( DecValTok , "0" )+  , ( NormalTok , "].swap(idx);" )+  ]+, [ ( NormalTok , "        }" ) ]+, []+, [ ( NormalTok , "        " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( KeywordTok , "false" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "    }" ) ]+, []+, [ ( NormalTok , "    " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " inner(blocks." )+  , ( DataTypeTok , "length" )+  , ( NormalTok , ".iota.array, word);" )+  ]+, [ ( NormalTok , "}" ) ]+, []+, [ ( DataTypeTok , "void" ) , ( NormalTok , " main() {" ) ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "enum" )+  , ( NormalTok , " Block[] blocks = " )+  , ( StringTok , "\"BO XK DQ CP NA GT RE TG QD FS" )+  ]+, [ ( StringTok+    , "                           JW HU VI AN OB ER FS LY PC ZM\""+    )+  , ( NormalTok , ".split;" )+  ]+, []+, [ ( NormalTok , "    " )+  , ( KeywordTok , "foreach" )+  , ( NormalTok , " (w; " )+  , ( StringTok , "\"\"" )+  , ( NormalTok , " ~ " )+  , ( StringTok , "\"A BARK BoOK TrEAT COmMoN SQUAD conFUsE\"" )+  , ( NormalTok , ".split)" )+  ]+, [ ( NormalTok , "        writefln(" )+  , ( SpecialStringTok , "`\"%s\" %s`" )+  , ( NormalTok , ", w, blocks.canMakeWord(w));" )+  ]+, []+, [ ( NormalTok , "    " ) , ( CommentTok , "// Extra test." ) ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "immutable" )+  , ( NormalTok , " Block[] blocks2 = [" )+  , ( StringTok , "\"AB\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"AB\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"AC\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"AC\"" )+  , ( NormalTok , "];" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "immutable" )+  , ( NormalTok , " word = " )+  , ( StringTok , "\"abba\"" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "    writefln(" )+  , ( SpecialStringTok , "`\"%s\" %s`" )+  , ( NormalTok , ", word, blocks2.canMakeWord(word));" )+  ]+, [ ( NormalTok , "}" ) ]+]
+ test/expected/abc.fortran.native view
@@ -0,0 +1,399 @@+[ [ ( CommentTok+    , "!-*- mode: compilation; default-directory: \"/tmp/\" -*-"+    )+  ]+, [ ( CommentTok , "!Compilation started at Thu Jun  5 01:52:03" )+  ]+, [ ( CommentTok , "!" ) ]+, [ ( CommentTok+    , "!make f && for a in '' a bark book treat common squad confuse ; do echo $a | ./f ; done"+    )+  ]+, [ ( CommentTok+    , "!gfortran -std=f2008 -Wall -fopenmp -ffree-form -fall-intrinsics -fimplicit-none -g f.f08 -o f"+    )+  ]+, [ ( CommentTok , "! T                      " ) ]+, [ ( CommentTok , "! T  A                    NA" ) ]+, [ ( CommentTok , "! T  BARK                 BO NA RE XK" ) ]+, [ ( CommentTok , "! F  BOOK                 OB BO -- --" ) ]+, [ ( CommentTok , "! T  TREAT                GT RE ER NA TG" ) ]+, [ ( CommentTok , "! F  COMMON               PC OB ZM -- -- --" )+  ]+, [ ( CommentTok , "! T  SQUAD                FS DQ HU NA QD" ) ]+, [ ( CommentTok+    , "! T  CONFUSE              CP BO NA FS HU FS RE"+    )+  ]+, [ ( CommentTok , "!" ) ]+, [ ( CommentTok , "!Compilation finished at Thu Jun  5 01:52:03" )+  ]+, []+, [ ( KeywordTok , "program" ) , ( NormalTok , " abc" ) ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "implicit" )+  , ( NormalTok , " " )+  , ( KeywordTok , "none" )+  ]+, [ ( NormalTok , "  " )+  , ( DataTypeTok , "integer" )+  , ( NormalTok , ", " )+  , ( DataTypeTok , "parameter" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "::" )+  , ( NormalTok , " nblocks " )+  , ( KeywordTok , "=" )+  , ( NormalTok , " " )+  , ( DecValTok , "20" )+  ]+, [ ( NormalTok , "  " )+  , ( DataTypeTok , "character(len=nblocks)" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "::" )+  , ( NormalTok , " goal" )+  ]+, [ ( NormalTok , "  " )+  , ( DataTypeTok , "integer" )+  , ( NormalTok , ", " )+  , ( DataTypeTok , "dimension(nblocks)" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "::" )+  , ( NormalTok , " solution" )+  ]+, [ ( NormalTok , "  " )+  , ( DataTypeTok , "character(len=2)" )+  , ( NormalTok , ", " )+  , ( DataTypeTok , "dimension(0:nblocks)" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "::" )+  , ( NormalTok , " blocks_copy, blocks " )+  , ( KeywordTok , "=" )+  , ( NormalTok , " " )+  , ( KeywordTok , "&" )+  ]+, [ ( NormalTok , "       " )+  , ( KeywordTok , "&(/" )+  , ( StringTok , "'--'" )+  , ( NormalTok , "," )+  , ( StringTok , "'BO'" )+  , ( NormalTok , "," )+  , ( StringTok , "'XK'" )+  , ( NormalTok , "," )+  , ( StringTok , "'DQ'" )+  , ( NormalTok , "," )+  , ( StringTok , "'CP'" )+  , ( NormalTok , "," )+  , ( StringTok , "'NA'" )+  , ( NormalTok , "," )+  , ( StringTok , "'GT'" )+  , ( NormalTok , "," )+  , ( StringTok , "'RE'" )+  , ( NormalTok , "," )+  , ( StringTok , "'TG'" )+  , ( NormalTok , "," )+  , ( StringTok , "'QD'" )+  , ( NormalTok , "," )+  , ( StringTok , "'FS'" )+  , ( NormalTok , "," )+  , ( StringTok , "'JW'" )+  , ( NormalTok , "," )+  , ( StringTok , "'HU'" )+  , ( NormalTok , "," )+  , ( StringTok , "'VI'" )+  , ( NormalTok , "," )+  , ( StringTok , "'AN'" )+  , ( NormalTok , "," )+  , ( StringTok , "'OB'" )+  , ( NormalTok , "," )+  , ( StringTok , "'ER'" )+  , ( NormalTok , "," )+  , ( StringTok , "'FS'" )+  , ( NormalTok , "," )+  , ( StringTok , "'LY'" )+  , ( NormalTok , "," )+  , ( StringTok , "'PC'" )+  , ( NormalTok , "," )+  , ( StringTok , "'ZM'" )+  , ( KeywordTok , "/)" )+  ]+, [ ( NormalTok , "  " )+  , ( DataTypeTok , "logical" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "::" )+  , ( NormalTok , " valid" )+  ]+, [ ( NormalTok , "  " )+  , ( DataTypeTok , "integer" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "::" )+  , ( NormalTok , " i, iostat" )+  ]+, [ ( NormalTok , "  " )+  , ( FunctionTok , "read(" )+  , ( DecValTok , "5" )+  , ( NormalTok , "," )+  , ( FunctionTok , "*" )+  , ( NormalTok , "," )+  , ( FunctionTok , "iostat" )+  , ( KeywordTok , "=" )+  , ( FunctionTok , "iostat)" )+  , ( NormalTok , " goal" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " (iostat " )+  , ( OperatorTok , ".ne." )+  , ( NormalTok , " " )+  , ( DecValTok , "0" )+  , ( NormalTok , ") goal " )+  , ( KeywordTok , "=" )+  , ( NormalTok , " " )+  , ( StringTok , "''" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "call" )+  , ( NormalTok , " ucase(goal)" )+  ]+, [ ( NormalTok , "  solution " )+  , ( KeywordTok , "=" )+  , ( NormalTok , " " )+  , ( DecValTok , "0" )+  ]+, [ ( NormalTok , "  blocks_copy " )+  , ( KeywordTok , "=" )+  , ( NormalTok , " blocks" )+  ]+, [ ( NormalTok , "  valid " )+  , ( KeywordTok , "=" )+  , ( NormalTok , " assign_block(goal(" )+  , ( DecValTok , "1" )+  , ( NormalTok , ":" )+  , ( BuiltInTok , "len_trim" )+  , ( NormalTok , "(goal)), blocks, solution, " )+  , ( DecValTok , "1" )+  , ( NormalTok , ")" )+  ]+, [ ( NormalTok , "  " )+  , ( FunctionTok , "write(" )+  , ( DecValTok , "6" )+  , ( NormalTok , "," )+  , ( FunctionTok , "*)" )+  , ( NormalTok , " valid, " )+  , ( StringTok , "' '" )+  , ( KeywordTok , "//" )+  , ( NormalTok , "goal, (" )+  , ( StringTok , "' '" )+  , ( KeywordTok , "//" )+  , ( NormalTok , "blocks_copy(solution(i)), i" )+  , ( KeywordTok , "=" )+  , ( DecValTok , "1" )+  , ( NormalTok , "," )+  , ( BuiltInTok , "len_trim" )+  , ( NormalTok , "(goal))" )+  ]+, []+, [ ( CommentTok , "contains" ) ]+, []+, [ ( NormalTok , "  " )+  , ( KeywordTok , "recursive" )+  , ( NormalTok , " " )+  , ( KeywordTok , "function" )+  , ( NormalTok , " assign_block(goal, blocks, solution, n) " )+  , ( KeywordTok , "result" )+  , ( NormalTok , "(valid)" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "implicit" )+  , ( NormalTok , " " )+  , ( KeywordTok , "none" )+  ]+, [ ( NormalTok , "    " )+  , ( DataTypeTok , "logical" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "::" )+  , ( NormalTok , " valid" )+  ]+, [ ( NormalTok , "    " )+  , ( DataTypeTok , "character(len=*)" )+  , ( NormalTok , ", " )+  , ( DataTypeTok , "intent(in)" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "::" )+  , ( NormalTok , " goal" )+  ]+, [ ( NormalTok , "    " )+  , ( DataTypeTok , "character(len=2)" )+  , ( NormalTok , ", " )+  , ( DataTypeTok , "dimension(0:)" )+  , ( NormalTok , ", " )+  , ( DataTypeTok , "intent(inout)" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "::" )+  , ( NormalTok , " blocks" )+  ]+, [ ( NormalTok , "    " )+  , ( DataTypeTok , "integer" )+  , ( NormalTok , ", " )+  , ( DataTypeTok , "dimension(:)" )+  , ( NormalTok , ", " )+  , ( DataTypeTok , "intent(out)" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "::" )+  , ( NormalTok , " solution" )+  ]+, [ ( NormalTok , "    " )+  , ( DataTypeTok , "integer" )+  , ( NormalTok , ", " )+  , ( DataTypeTok , "intent(in)" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "::" )+  , ( NormalTok , " n" )+  ]+, [ ( NormalTok , "    " )+  , ( DataTypeTok , "integer" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "::" )+  , ( NormalTok , " i" )+  ]+, [ ( NormalTok , "    " )+  , ( DataTypeTok , "character(len=2)" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "::" )+  , ( NormalTok , " backing_store" )+  ]+, [ ( NormalTok , "    valid " )+  , ( KeywordTok , "=" )+  , ( NormalTok , " " )+  , ( ConstantTok , ".true." )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " (" )+  , ( FunctionTok , "len" )+  , ( NormalTok , "(goal)" )+  , ( KeywordTok , "+" )+  , ( DecValTok , "1" )+  , ( NormalTok , " " )+  , ( OperatorTok , ".eq." )+  , ( NormalTok , " n) " )+  , ( KeywordTok , "return" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "do" )+  , ( NormalTok , " i" )+  , ( KeywordTok , "=" )+  , ( DecValTok , "1" )+  , ( NormalTok , ", " )+  , ( FunctionTok , "size" )+  , ( NormalTok , "(blocks)" )+  ]+, [ ( NormalTok , "       " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " (" )+  , ( BuiltInTok , "index" )+  , ( NormalTok , "(blocks(i),goal(n:n)) " )+  , ( OperatorTok , ".ne." )+  , ( NormalTok , " " )+  , ( DecValTok , "0" )+  , ( NormalTok , ") " )+  , ( KeywordTok , "then" )+  ]+, [ ( NormalTok , "          backing_store " )+  , ( KeywordTok , "=" )+  , ( NormalTok , " blocks(i)" )+  ]+, [ ( NormalTok , "          blocks(i) " )+  , ( KeywordTok , "=" )+  , ( NormalTok , " " )+  , ( StringTok , "''" )+  ]+, [ ( NormalTok , "          solution(n) " )+  , ( KeywordTok , "=" )+  , ( NormalTok , " i" )+  ]+, [ ( NormalTok , "          " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " (assign_block(goal, blocks, solution, n" )+  , ( KeywordTok , "+" )+  , ( DecValTok , "1" )+  , ( NormalTok , ")) " )+  , ( KeywordTok , "return" )+  ]+, [ ( NormalTok , "          blocks(i) " )+  , ( KeywordTok , "=" )+  , ( NormalTok , " backing_store" )+  ]+, [ ( NormalTok , "       " ) , ( KeywordTok , "end if" ) ]+, [ ( NormalTok , "    " ) , ( KeywordTok , "end do" ) ]+, [ ( NormalTok , "    valid " )+  , ( KeywordTok , "=" )+  , ( NormalTok , " " )+  , ( ConstantTok , ".false." )+  ]+, [ ( NormalTok , "    " ) , ( KeywordTok , "return" ) ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "end function" )+  , ( NormalTok , " assign_block" )+  ]+, []+, [ ( NormalTok , "  " )+  , ( KeywordTok , "subroutine" )+  , ( NormalTok , " ucase(a)" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "implicit" )+  , ( NormalTok , " " )+  , ( KeywordTok , "none" )+  ]+, [ ( NormalTok , "    " )+  , ( DataTypeTok , "character(len=*)" )+  , ( NormalTok , ", " )+  , ( DataTypeTok , "intent(inout)" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "::" )+  , ( NormalTok , " a" )+  ]+, [ ( NormalTok , "    " )+  , ( DataTypeTok , "integer" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "::" )+  , ( NormalTok , " i, j" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "do" )+  , ( NormalTok , " i " )+  , ( KeywordTok , "=" )+  , ( NormalTok , " " )+  , ( DecValTok , "1" )+  , ( NormalTok , ", " )+  , ( BuiltInTok , "len_trim" )+  , ( NormalTok , "(a)" )+  ]+, [ ( NormalTok , "       j " )+  , ( KeywordTok , "=" )+  , ( NormalTok , " " )+  , ( BuiltInTok , "index" )+  , ( NormalTok , "(" )+  , ( StringTok , "'abcdefghijklmnopqrstuvwxyz'" )+  , ( NormalTok , ",a(i:i))" )+  ]+, [ ( NormalTok , "       " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " (j " )+  , ( OperatorTok , ".ne." )+  , ( NormalTok , " " )+  , ( DecValTok , "0" )+  , ( NormalTok , ") a(i:i) " )+  , ( KeywordTok , "=" )+  , ( NormalTok , " " )+  , ( StringTok , "'ABCDEFGHIJKLMNOPQRSTUVWXYZ'" )+  , ( NormalTok , "(j:j)" )+  ]+, [ ( NormalTok , "    " ) , ( KeywordTok , "end do" ) ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "end subroutine" )+  , ( NormalTok , " ucase" )+  ]+, []+, [ ( KeywordTok , "end program" ) , ( NormalTok , " abc" ) ]+]
+ test/expected/abc.go.native view
@@ -0,0 +1,153 @@+[ [ ( KeywordTok , "package" ) , ( NormalTok , " main" ) ]+, []+, [ ( KeywordTok , "import" ) , ( NormalTok , " (" ) ]+, [ ( NormalTok , "        " ) , ( StringTok , "\"fmt\"" ) ]+, [ ( NormalTok , "        " ) , ( StringTok , "\"strings\"" ) ]+, [ ( NormalTok , ")" ) ]+, []+, [ ( KeywordTok , "func" )+  , ( NormalTok , " newSpeller(blocks " )+  , ( DataTypeTok , "string" )+  , ( NormalTok , ") " )+  , ( KeywordTok , "func" )+  , ( NormalTok , "(" )+  , ( DataTypeTok , "string" )+  , ( NormalTok , ") " )+  , ( DataTypeTok , "bool" )+  , ( NormalTok , " {" )+  ]+, [ ( NormalTok , "        bl := strings.Fields(blocks)" ) ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( KeywordTok , "func" )+  , ( NormalTok , "(word " )+  , ( DataTypeTok , "string" )+  , ( NormalTok , ") " )+  , ( DataTypeTok , "bool" )+  , ( NormalTok , " {" )+  ]+, [ ( NormalTok , "                " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " r(word, bl)" )+  ]+, [ ( NormalTok , "        }" ) ]+, [ ( NormalTok , "}" ) ]+, []+, [ ( KeywordTok , "func" )+  , ( NormalTok , " r(word " )+  , ( DataTypeTok , "string" )+  , ( NormalTok , ", bl []" )+  , ( DataTypeTok , "string" )+  , ( NormalTok , ") " )+  , ( DataTypeTok , "bool" )+  , ( NormalTok , " {" )+  ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " word == " )+  , ( StringTok , "\"\"" )+  , ( NormalTok , " {" )+  ]+, [ ( NormalTok , "                " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( OtherTok , "true" )+  ]+, [ ( NormalTok , "        }" ) ]+, [ ( NormalTok , "        c := word[" )+  , ( DecValTok , "0" )+  , ( NormalTok , "] | " )+  , ( DecValTok , "32" )+  ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "for" )+  , ( NormalTok , " i, b := " )+  , ( KeywordTok , "range" )+  , ( NormalTok , " bl {" )+  ]+, [ ( NormalTok , "                " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " c == b[" )+  , ( DecValTok , "0" )+  , ( NormalTok , "]|" )+  , ( DecValTok , "32" )+  , ( NormalTok , " || c == b[" )+  , ( DecValTok , "1" )+  , ( NormalTok , "]|" )+  , ( DecValTok , "32" )+  , ( NormalTok , " {" )+  ]+, [ ( NormalTok , "                        bl[i], bl[" )+  , ( DecValTok , "0" )+  , ( NormalTok , "] = bl[" )+  , ( DecValTok , "0" )+  , ( NormalTok , "], b" )+  ]+, [ ( NormalTok , "                        " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " r(word[" )+  , ( DecValTok , "1" )+  , ( NormalTok , ":], bl[" )+  , ( DecValTok , "1" )+  , ( NormalTok , ":]) == " )+  , ( OtherTok , "true" )+  , ( NormalTok , " {" )+  ]+, [ ( NormalTok , "                                " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( OtherTok , "true" )+  ]+, [ ( NormalTok , "                        }" ) ]+, [ ( NormalTok , "                        bl[i], bl[" )+  , ( DecValTok , "0" )+  , ( NormalTok , "] = bl[" )+  , ( DecValTok , "0" )+  , ( NormalTok , "], bl[i]" )+  ]+, [ ( NormalTok , "                }" ) ]+, [ ( NormalTok , "        }" ) ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( OtherTok , "false" )+  ]+, [ ( NormalTok , "}" ) ]+, []+, [ ( KeywordTok , "func" ) , ( NormalTok , " main() {" ) ]+, [ ( NormalTok , "        sp := newSpeller(" ) ]+, [ ( NormalTok , "                " )+  , ( StringTok+    , "\"BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM\""+    )+  , ( NormalTok , ")" )+  ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "for" )+  , ( NormalTok , " _, word := " )+  , ( KeywordTok , "range" )+  , ( NormalTok , " []" )+  , ( DataTypeTok , "string" )+  , ( NormalTok , "{" )+  ]+, [ ( NormalTok , "                " )+  , ( StringTok , "\"A\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"BARK\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"BOOK\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"TREAT\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"COMMON\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"SQUAD\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"CONFUSE\"" )+  , ( NormalTok , "} {" )+  ]+, [ ( NormalTok , "                fmt.Println(word, sp(word))" ) ]+, [ ( NormalTok , "        }" ) ]+, [ ( NormalTok , "}" ) ]+]
+ test/expected/abc.haskell.native view
@@ -0,0 +1,128 @@+[ [ ( KeywordTok , "import " )+  , ( DataTypeTok , "Data.List" )+  , ( NormalTok , " (delete)" )+  ]+, [ ( KeywordTok , "import " )+  , ( DataTypeTok , "Data.Char" )+  , ( NormalTok , " (toUpper)" )+  ]+, []+, [ ( CommentTok+    , "-- returns list of all solutions, each solution being a list of blocks"+    )+  ]+, [ ( OtherTok , "abc ::" )+  , ( NormalTok , " (" )+  , ( DataTypeTok , "Eq" )+  , ( NormalTok , " a) " )+  , ( OtherTok , "=>" )+  , ( NormalTok , " [[a]] " )+  , ( OtherTok , "->" )+  , ( NormalTok , " [a] " )+  , ( OtherTok , "->" )+  , ( NormalTok , " [[[a]]]" )+  ]+, [ ( NormalTok , "abc _ [] " )+  , ( FunctionTok , "=" )+  , ( NormalTok , " [[]]" )+  ]+, [ ( NormalTok , "abc blocks (c" )+  , ( FunctionTok , ":" )+  , ( NormalTok , "cs) " )+  , ( FunctionTok , "=" )+  , ( NormalTok , " [b" )+  , ( FunctionTok , ":" )+  , ( NormalTok , "ans " )+  , ( FunctionTok , "|" )+  , ( NormalTok , " b " )+  , ( OtherTok , "<-" )+  , ( NormalTok , " blocks, c " )+  , ( OtherTok , "`elem`" )+  , ( NormalTok , " b," )+  ]+, [ ( NormalTok , "                             ans " )+  , ( OtherTok , "<-" )+  , ( NormalTok , " abc (delete b blocks) cs]" )+  ]+, []+, [ ( NormalTok , "blocks " )+  , ( FunctionTok , "=" )+  , ( NormalTok , " [" )+  , ( StringTok , "\"BO\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"XK\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"DQ\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"CP\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"NA\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"GT\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"RE\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"TG\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"QD\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"FS\"" )+  , ( NormalTok , "," )+  ]+, [ ( NormalTok , "          " )+  , ( StringTok , "\"JW\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"HU\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"VI\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"AN\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"OB\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"ER\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"FS\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"LY\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"PC\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"ZM\"" )+  , ( NormalTok , "]" )+  ]+, []+, [ ( OtherTok , "main ::" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "IO" )+  , ( NormalTok , " ()" )+  ]+, [ ( NormalTok , "main " )+  , ( FunctionTok , "=" )+  , ( NormalTok , " mapM_ (\\w " )+  , ( OtherTok , "->" )+  , ( NormalTok , " print (w, not " )+  , ( FunctionTok , "." )+  , ( NormalTok , " null " )+  , ( FunctionTok , "$" )+  , ( NormalTok , " abc blocks (map toUpper w)))" )+  ]+, [ ( NormalTok , "         [" )+  , ( StringTok , "\"\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"A\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"BARK\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"BoOK\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"TrEAT\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"COmMoN\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"SQUAD\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"conFUsE\"" )+  , ( NormalTok , "]" )+  ]+]
+ test/expected/abc.java.native view
@@ -0,0 +1,341 @@+[ [ ( KeywordTok , "import" )+  , ( ImportTok , " java.util.Arrays;" )+  ]+, []+, [ ( KeywordTok , "public" )+  , ( NormalTok , " " )+  , ( KeywordTok , "class" )+  , ( NormalTok , " ABC{" )+  ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "private" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "static" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "void" )+  , ( NormalTok , " " )+  , ( FunctionTok , "swap" )+  , ( NormalTok , "(" )+  , ( DataTypeTok , "int" )+  , ( NormalTok , " i, " )+  , ( DataTypeTok , "int" )+  , ( NormalTok , " j, " )+  , ( BuiltInTok , "Object" )+  , ( KeywordTok , "... " )+  , ( NormalTok , "arr){" )+  ]+, [ ( NormalTok , "                " )+  , ( BuiltInTok , "Object" )+  , ( NormalTok , " tmp = arr[i];" )+  ]+, [ ( NormalTok , "                arr[i] = arr[j];" ) ]+, [ ( NormalTok , "                arr[j] = tmp;" ) ]+, [ ( NormalTok , "        }" ) ]+, [ ( NormalTok , "        " ) ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "public" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "static" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "boolean" )+  , ( NormalTok , " " )+  , ( FunctionTok , "canMakeWord" )+  , ( NormalTok , "(" )+  , ( BuiltInTok , "String" )+  , ( NormalTok , " word, " )+  , ( BuiltInTok , "String" )+  , ( KeywordTok , "... " )+  , ( NormalTok , "blocks) {" )+  ]+, [ ( NormalTok , "            " )+  , ( KeywordTok , "if" )+  , ( NormalTok , "(word." )+  , ( FunctionTok , "length" )+  , ( NormalTok , "() == " )+  , ( DecValTok , "0" )+  , ( NormalTok , ")" )+  ]+, [ ( NormalTok , "                " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( KeywordTok , "true" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "         " ) ]+, [ ( NormalTok , "            " )+  , ( DataTypeTok , "char" )+  , ( NormalTok , " c = " )+  , ( BuiltInTok , "Character" )+  , ( NormalTok , "." )+  , ( FunctionTok , "toUpperCase" )+  , ( NormalTok , "(word." )+  , ( FunctionTok , "charAt" )+  , ( NormalTok , "(" )+  , ( DecValTok , "0" )+  , ( NormalTok , "));" )+  ]+, [ ( NormalTok , "            " )+  , ( KeywordTok , "for" )+  , ( NormalTok , "(" )+  , ( DataTypeTok , "int" )+  , ( NormalTok , " i = " )+  , ( DecValTok , "0" )+  , ( NormalTok , "; i < blocks." )+  , ( FunctionTok , "length" )+  , ( NormalTok , "; i++) {" )+  ]+, [ ( NormalTok , "                " )+  , ( BuiltInTok , "String" )+  , ( NormalTok , " b = blocks[i];" )+  ]+, [ ( NormalTok , "                " )+  , ( KeywordTok , "if" )+  , ( NormalTok , "(" )+  , ( BuiltInTok , "Character" )+  , ( NormalTok , "." )+  , ( FunctionTok , "toUpperCase" )+  , ( NormalTok , "(b." )+  , ( FunctionTok , "charAt" )+  , ( NormalTok , "(" )+  , ( DecValTok , "0" )+  , ( NormalTok , ")) != c && " )+  , ( BuiltInTok , "Character" )+  , ( NormalTok , "." )+  , ( FunctionTok , "toUpperCase" )+  , ( NormalTok , "(b." )+  , ( FunctionTok , "charAt" )+  , ( NormalTok , "(" )+  , ( DecValTok , "1" )+  , ( NormalTok , ")) != c)" )+  ]+, [ ( NormalTok , "                    " )+  , ( KeywordTok , "continue" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "                " )+  , ( FunctionTok , "swap" )+  , ( NormalTok , "(" )+  , ( DecValTok , "0" )+  , ( NormalTok , ", i, blocks);" )+  ]+, [ ( NormalTok , "                " )+  , ( KeywordTok , "if" )+  , ( NormalTok , "(" )+  , ( FunctionTok , "canMakeWord" )+  , ( NormalTok , "(word." )+  , ( FunctionTok , "substring" )+  , ( NormalTok , "(" )+  , ( DecValTok , "1" )+  , ( NormalTok , "), " )+  , ( BuiltInTok , "Arrays" )+  , ( NormalTok , "." )+  , ( FunctionTok , "copyOfRange" )+  , ( NormalTok , "(blocks, " )+  , ( DecValTok , "1" )+  , ( NormalTok , ", blocks." )+  , ( FunctionTok , "length" )+  , ( NormalTok , ")))" )+  ]+, [ ( NormalTok , "                    " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( KeywordTok , "true" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "                " )+  , ( FunctionTok , "swap" )+  , ( NormalTok , "(" )+  , ( DecValTok , "0" )+  , ( NormalTok , ", i, blocks);" )+  ]+, [ ( NormalTok , "            }" ) ]+, [ ( NormalTok , "         " ) ]+, [ ( NormalTok , "            " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( KeywordTok , "false" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "        }" ) ]+, [ ( NormalTok , "        " ) ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "public" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "static" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "void" )+  , ( NormalTok , " " )+  , ( FunctionTok , "main" )+  , ( NormalTok , "(" )+  , ( BuiltInTok , "String" )+  , ( NormalTok , "[] args){" )+  ]+, [ ( NormalTok , "                " )+  , ( BuiltInTok , "String" )+  , ( NormalTok , "[] blocks = {" )+  , ( StringTok , "\"BO\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"XK\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"DQ\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"CP\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"NA\"" )+  , ( NormalTok , ", " )+  ]+, [ ( NormalTok , "                                " )+  , ( StringTok , "\"GT\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"RE\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"TG\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"QD\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"FS\"" )+  , ( NormalTok , ", " )+  ]+, [ ( NormalTok , "                                " )+  , ( StringTok , "\"JW\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"HU\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"VI\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"AN\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"OB\"" )+  , ( NormalTok , ", " )+  ]+, [ ( NormalTok , "                                " )+  , ( StringTok , "\"ER\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"FS\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"LY\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"PC\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"ZM\"" )+  , ( NormalTok , "};" )+  ]+, []+, [ ( NormalTok , "                " )+  , ( BuiltInTok , "System" )+  , ( NormalTok , "." )+  , ( FunctionTok , "out" )+  , ( NormalTok , "." )+  , ( FunctionTok , "println" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"" )+  , ( SpecialCharTok , "\\\"\\\"" )+  , ( StringTok , ": \"" )+  , ( NormalTok , " + " )+  , ( FunctionTok , "canMakeWord" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"\"" )+  , ( NormalTok , ", blocks));" )+  ]+, [ ( NormalTok , "                " )+  , ( BuiltInTok , "System" )+  , ( NormalTok , "." )+  , ( FunctionTok , "out" )+  , ( NormalTok , "." )+  , ( FunctionTok , "println" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"A: \"" )+  , ( NormalTok , " + " )+  , ( FunctionTok , "canMakeWord" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"A\"" )+  , ( NormalTok , ", blocks));" )+  ]+, [ ( NormalTok , "                " )+  , ( BuiltInTok , "System" )+  , ( NormalTok , "." )+  , ( FunctionTok , "out" )+  , ( NormalTok , "." )+  , ( FunctionTok , "println" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"BARK: \"" )+  , ( NormalTok , " + " )+  , ( FunctionTok , "canMakeWord" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"BARK\"" )+  , ( NormalTok , ", blocks));" )+  ]+, [ ( NormalTok , "                " )+  , ( BuiltInTok , "System" )+  , ( NormalTok , "." )+  , ( FunctionTok , "out" )+  , ( NormalTok , "." )+  , ( FunctionTok , "println" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"book: \"" )+  , ( NormalTok , " + " )+  , ( FunctionTok , "canMakeWord" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"book\"" )+  , ( NormalTok , ", blocks));" )+  ]+, [ ( NormalTok , "                " )+  , ( BuiltInTok , "System" )+  , ( NormalTok , "." )+  , ( FunctionTok , "out" )+  , ( NormalTok , "." )+  , ( FunctionTok , "println" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"treat: \"" )+  , ( NormalTok , " + " )+  , ( FunctionTok , "canMakeWord" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"treat\"" )+  , ( NormalTok , ", blocks));" )+  ]+, [ ( NormalTok , "                " )+  , ( BuiltInTok , "System" )+  , ( NormalTok , "." )+  , ( FunctionTok , "out" )+  , ( NormalTok , "." )+  , ( FunctionTok , "println" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"COMMON: \"" )+  , ( NormalTok , " + " )+  , ( FunctionTok , "canMakeWord" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"COMMON\"" )+  , ( NormalTok , ", blocks));" )+  ]+, [ ( NormalTok , "                " )+  , ( BuiltInTok , "System" )+  , ( NormalTok , "." )+  , ( FunctionTok , "out" )+  , ( NormalTok , "." )+  , ( FunctionTok , "println" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"SQuAd: \"" )+  , ( NormalTok , " + " )+  , ( FunctionTok , "canMakeWord" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"SQuAd\"" )+  , ( NormalTok , ", blocks));" )+  ]+, [ ( NormalTok , "                " )+  , ( BuiltInTok , "System" )+  , ( NormalTok , "." )+  , ( FunctionTok , "out" )+  , ( NormalTok , "." )+  , ( FunctionTok , "println" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"CONFUSE: \"" )+  , ( NormalTok , " + " )+  , ( FunctionTok , "canMakeWord" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"CONFUSE\"" )+  , ( NormalTok , ", blocks));" )+  ]+, [ ( NormalTok , "                " ) ]+, [ ( NormalTok , "        }" ) ]+, [ ( NormalTok , "}" ) ]+]
+ test/expected/abc.javascript.native view
@@ -0,0 +1,192 @@+[ [ ( KeywordTok , "let" )+  , ( NormalTok , " characters " )+  , ( OperatorTok , "=" )+  , ( NormalTok , " " )+  , ( StringTok+    , "\"BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM\""+    )+  , ( OperatorTok , ";" )+  ]+, [ ( KeywordTok , "let" )+  , ( NormalTok , " blocks " )+  , ( OperatorTok , "=" )+  , ( NormalTok , " " )+  , ( VariableTok , "characters" )+  , ( NormalTok , "." )+  , ( AttributeTok , "split" )+  , ( NormalTok , "(" )+  , ( StringTok , "\" \"" )+  , ( NormalTok , ")." )+  , ( AttributeTok , "map" )+  , ( NormalTok , "(pair " )+  , ( OperatorTok , "=>" )+  , ( NormalTok , " " )+  , ( VariableTok , "pair" )+  , ( NormalTok , "." )+  , ( AttributeTok , "split" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"\"" )+  , ( NormalTok , "))" )+  , ( OperatorTok , ";" )+  ]+, [ ( NormalTok , " " ) ]+, [ ( KeywordTok , "function" )+  , ( NormalTok , " " )+  , ( AttributeTok , "isWordPossible" )+  , ( NormalTok , "(word) " )+  , ( OperatorTok , "{" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "var" )+  , ( NormalTok , " letters " )+  , ( OperatorTok , "=" )+  , ( NormalTok , " [..." )+  , ( VariableTok , "word" )+  , ( NormalTok , "." )+  , ( AttributeTok , "toUpperCase" )+  , ( NormalTok , "()]" )+  , ( OperatorTok , ";" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "var" )+  , ( NormalTok , " length " )+  , ( OperatorTok , "=" )+  , ( NormalTok , " " )+  , ( VariableTok , "letters" )+  , ( NormalTok , "." )+  , ( AttributeTok , "length" )+  , ( OperatorTok , ";" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "var" )+  , ( NormalTok , " copy " )+  , ( OperatorTok , "=" )+  , ( NormalTok , " " )+  , ( KeywordTok , "new" )+  , ( NormalTok , " " )+  , ( AttributeTok , "Set" )+  , ( NormalTok , "(blocks)" )+  , ( OperatorTok , ";" )+  ]+, []+, [ ( NormalTok , "  " )+  , ( ControlFlowTok , "for" )+  , ( NormalTok , " (" )+  , ( KeywordTok , "let" )+  , ( NormalTok , " letter of letters) " )+  , ( OperatorTok , "{" )+  ]+, [ ( NormalTok , "    " )+  , ( ControlFlowTok , "for" )+  , ( NormalTok , " (" )+  , ( KeywordTok , "let" )+  , ( NormalTok , " block of copy) " )+  , ( OperatorTok , "{" )+  ]+, [ ( NormalTok , "      " )+  , ( KeywordTok , "let" )+  , ( NormalTok , " index " )+  , ( OperatorTok , "=" )+  , ( NormalTok , " " )+  , ( VariableTok , "block" )+  , ( NormalTok , "." )+  , ( AttributeTok , "indexOf" )+  , ( NormalTok , "(letter)" )+  , ( OperatorTok , ";" )+  ]+, [ ( NormalTok , " " ) ]+, [ ( NormalTok , "      " )+  , ( ControlFlowTok , "if" )+  , ( NormalTok , " (index " )+  , ( OperatorTok , "!==" )+  , ( NormalTok , " " )+  , ( OperatorTok , "-" )+  , ( DecValTok , "1" )+  , ( NormalTok , ") " )+  , ( OperatorTok , "{" )+  ]+, [ ( NormalTok , "        length" ) , ( OperatorTok , "--;" ) ]+, [ ( NormalTok , "        " )+  , ( VariableTok , "copy" )+  , ( NormalTok , "." )+  , ( AttributeTok , "delete" )+  , ( NormalTok , "(block)" )+  , ( OperatorTok , ";" )+  ]+, [ ( NormalTok , "        " )+  , ( ControlFlowTok , "break" )+  , ( OperatorTok , ";" )+  , ( NormalTok , "  " )+  ]+, [ ( NormalTok , "      " ) , ( OperatorTok , "}" ) ]+, [ ( NormalTok , "    " ) , ( OperatorTok , "}" ) ]+, []+, [ ( NormalTok , "  " ) , ( OperatorTok , "}" ) ]+, [ ( NormalTok , "  " )+  , ( ControlFlowTok , "return" )+  , ( NormalTok , " " )+  , ( OperatorTok , "!" )+  , ( NormalTok , "length" )+  , ( OperatorTok , ";" )+  ]+, [ ( OperatorTok , "}" ) , ( NormalTok , "    " ) ]+, [ ( NormalTok , " " ) ]+, [ ( NormalTok , "[ " ) ]+, [ ( NormalTok , "  " )+  , ( StringTok , "\"A\"" )+  , ( OperatorTok , "," )+  , ( NormalTok , " " )+  ]+, [ ( NormalTok , "  " )+  , ( StringTok , "\"BARK\"" )+  , ( OperatorTok , "," )+  , ( NormalTok , " " )+  ]+, [ ( NormalTok , "  " )+  , ( StringTok , "\"BOOK\"" )+  , ( OperatorTok , "," )+  , ( NormalTok , " " )+  ]+, [ ( NormalTok , "  " )+  , ( StringTok , "\"TREAT\"" )+  , ( OperatorTok , "," )+  , ( NormalTok , " " )+  ]+, [ ( NormalTok , "  " )+  , ( StringTok , "\"COMMON\"" )+  , ( OperatorTok , "," )+  , ( NormalTok , " " )+  ]+, [ ( NormalTok , "  " )+  , ( StringTok , "\"SQUAD\"" )+  , ( OperatorTok , "," )+  , ( NormalTok , " " )+  ]+, [ ( NormalTok , "  " )+  , ( StringTok , "\"CONFUSE\"" )+  , ( NormalTok , " " )+  ]+, [ ( NormalTok , "]." )+  , ( AttributeTok , "forEach" )+  , ( NormalTok , "(word " )+  , ( OperatorTok , "=>" )+  , ( NormalTok , " " )+  , ( VariableTok , "console" )+  , ( NormalTok , "." )+  , ( AttributeTok , "log" )+  , ( NormalTok , "(" )+  , ( VerbatimStringTok , "`" )+  , ( SpecialCharTok , "${" )+  , ( NormalTok , "word" )+  , ( SpecialCharTok , "}" )+  , ( VerbatimStringTok , ": " )+  , ( SpecialCharTok , "${" )+  , ( AttributeTok , "isWordPossible" )+  , ( NormalTok , "(word)" )+  , ( SpecialCharTok , "}" )+  , ( VerbatimStringTok , "`" )+  , ( NormalTok , "))" )+  , ( OperatorTok , ";" )+  ]+, []+]
+ test/expected/abc.julia.native view
@@ -0,0 +1,35 @@+[ [ ( KeywordTok , "function" )+  , ( NormalTok , " abc (str, list)" )+  ]+, [ ( NormalTok , "  isempty(str) && " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " true" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "for" )+  , ( NormalTok , " i = " )+  , ( FloatTok , "1" )+  , ( NormalTok , ":length(list)" )+  ]+, [ ( NormalTok , "    str[" )+  , ( KeywordTok , "end" )+  , ( NormalTok , "] " )+  , ( KeywordTok , "in" )+  , ( NormalTok , " list[i] && " )+  ]+, [ ( NormalTok , "    any([abc(str[" )+  , ( FloatTok , "1" )+  , ( NormalTok , ":" )+  , ( KeywordTok , "end" )+  , ( NormalTok , "-" )+  , ( FloatTok , "1" )+  , ( NormalTok , "], deleteat!(copy(list), i))]) &&" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " true" )+  ]+, [ ( NormalTok , "  " ) , ( KeywordTok , "end" ) ]+, [ ( NormalTok , "  false" ) ]+, [ ( KeywordTok , "end" ) ]+]
+ test/expected/abc.kotlin.native view
@@ -0,0 +1,305 @@+[ [ ( KeywordTok , "import" )+  , ( NormalTok , " " )+  , ( ImportTok , "java.util.Arrays" )+  ]+, []+, [ ( CommentTok , "/*" ) ]+, [ ( CommentTok , "    Swap elements i and j of a Kotlin Array." )+  ]+, [ ( CommentTok , " */" ) ]+, [ ( KeywordTok , "fun" )+  , ( NormalTok , " <" )+  , ( DataTypeTok , "T" )+  , ( NormalTok , "> " )+  , ( FunctionTok , "Array" )+  , ( NormalTok , "<" )+  , ( DataTypeTok , "T" )+  , ( NormalTok , ">." )+  , ( FunctionTok , "swap" )+  , ( NormalTok , "(" )+  , ( VariableTok , "i" )+  , ( NormalTok , ": " )+  , ( DataTypeTok , "Int" )+  , ( NormalTok , ", " )+  , ( VariableTok , "j" )+  , ( NormalTok , ": " )+  , ( DataTypeTok , "Int" )+  , ( NormalTok , ") {" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "val" )+  , ( NormalTok , " " )+  , ( VariableTok , "tmp" )+  , ( NormalTok , " = " )+  , ( KeywordTok , "this" )+  , ( NormalTok , "[i]" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "this" )+  , ( NormalTok , "[i] = " )+  , ( KeywordTok , "this" )+  , ( NormalTok , "[j]" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "this" )+  , ( NormalTok , "[j] = tmp" )+  ]+, [ ( NormalTok , "}" ) ]+, []+, [ ( KeywordTok , "data" )+  , ( NormalTok , " " )+  , ( KeywordTok , "class" )+  , ( NormalTok , " Block(" )+  , ( KeywordTok , "val" )+  , ( NormalTok , " " )+  , ( VariableTok , "block" )+  , ( NormalTok , ": " )+  , ( DataTypeTok , "String" )+  , ( NormalTok , ")" )+  ]+, []+, [ ( NormalTok , "/*" ) ]+, [ ( NormalTok+    , " *  Not the most elegant way but interesting from an highlighting perspective ;)"+    )+  ]+, [ ( NormalTok , " */" ) ]+, [ ( KeywordTok , "public" )+  , ( NormalTok , " " )+  , ( KeywordTok , "class" )+  , ( NormalTok , " ABC() {" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "class" )+  , ( NormalTok , " " )+  , ( KeywordTok , "object" )+  , ( NormalTok , " {" )+  ]+, []+, [ ( NormalTok , "        " )+  , ( KeywordTok , "public" )+  , ( NormalTok , " " )+  , ( KeywordTok , "fun" )+  , ( NormalTok , " " )+  , ( FunctionTok , "canMakeWord" )+  , ( NormalTok , "(" )+  , ( VariableTok , "word" )+  , ( NormalTok , ": " )+  , ( DataTypeTok , "String" )+  , ( NormalTok , ", " )+  , ( VariableTok , "blocks" )+  , ( NormalTok , ": " )+  , ( DataTypeTok , "Array" )+  , ( NormalTok , "<" )+  , ( VariableTok , "Block" )+  , ( NormalTok , ">): " )+  , ( DataTypeTok , "Boolean" )+  , ( NormalTok , " {" )+  ]+, [ ( NormalTok , "            " )+  , ( ControlFlowTok , "if" )+  , ( NormalTok , " (word.length() == " )+  , ( DecValTok , "0" )+  , ( NormalTok , ")" )+  ]+, [ ( NormalTok , "                " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( KeywordTok , "true" )+  ]+, []+, [ ( NormalTok , "            " )+  , ( KeywordTok , "val" )+  , ( NormalTok , " " )+  , ( VariableTok , "c" )+  , ( NormalTok , " = Character.toUpperCase(word.charAt(" )+  , ( DecValTok , "0" )+  , ( NormalTok , "))" )+  ]+, [ ( NormalTok , "            " )+  , ( ControlFlowTok , "for" )+  , ( NormalTok , " (i " )+  , ( KeywordTok , "in" )+  , ( NormalTok , " " )+  , ( DecValTok , "0" )+  , ( NormalTok , "..blocks.size - " )+  , ( DecValTok , "1" )+  , ( NormalTok , ") {" )+  ]+, [ ( NormalTok , "                " )+  , ( KeywordTok , "val" )+  , ( NormalTok , " " )+  , ( VariableTok , "b" )+  , ( NormalTok , " = blocks[i]" )+  ]+, [ ( NormalTok , "                " )+  , ( ControlFlowTok , "if" )+  , ( NormalTok , " (Character.toUpperCase(b.block.charAt(" )+  , ( DecValTok , "0" )+  , ( NormalTok+    , ")) != c && Character.toUpperCase(b.block.charAt("+    )+  , ( DecValTok , "1" )+  , ( NormalTok , ")) != c)" )+  ]+, [ ( NormalTok , "                    " )+  , ( ControlFlowTok , "continue" )+  ]+, [ ( NormalTok , "                blocks.swap(" )+  , ( DecValTok , "0" )+  , ( NormalTok , ", i)" )+  ]+, [ ( NormalTok , "                " )+  , ( ControlFlowTok , "if" )+  , ( NormalTok , " (canMakeWord(word.substring(" )+  , ( DecValTok , "1" )+  , ( NormalTok , "), Arrays.copyOfRange(blocks, " )+  , ( DecValTok , "1" )+  , ( NormalTok , ", blocks.size)))" )+  ]+, [ ( NormalTok , "                    " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( KeywordTok , "true" )+  ]+, [ ( NormalTok , "                blocks.swap(" )+  , ( DecValTok , "0" )+  , ( NormalTok , ", i)" )+  ]+, [ ( NormalTok , "            }" ) ]+, []+, [ ( NormalTok , "            " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( KeywordTok , "false" )+  ]+, [ ( NormalTok , "        }" ) ]+, []+, [ ( NormalTok , "        " )+  , ( KeywordTok , "public" )+  , ( NormalTok , " " )+  , ( KeywordTok , "fun" )+  , ( NormalTok , " " )+  , ( FunctionTok , "main" )+  , ( NormalTok , "(" )+  , ( VariableTok , "args" )+  , ( NormalTok , ": " )+  , ( DataTypeTok , "Array" )+  , ( NormalTok , "<" )+  , ( VariableTok , "String" )+  , ( NormalTok , ">) {" )+  ]+, []+, [ ( NormalTok , "            " )+  , ( KeywordTok , "val" )+  , ( NormalTok , " " )+  , ( VariableTok , "blocksString" )+  , ( NormalTok , " = array(" )+  , ( StringTok , "\"BO\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"XK\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"DQ\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"CP\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"NA\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"GT\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"RE\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"TG\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"QD\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"FS\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"JW\"" )+  , ( NormalTok , "," )+  ]+, [ ( NormalTok , "                                             " )+  , ( StringTok , "\"HU\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"VI\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"AN\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"OB\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"ER\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"FS\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"LY\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"PC\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"ZM\"" )+  , ( NormalTok , ");" )+  ]+, []+, [ ( NormalTok , "            " )+  , ( KeywordTok , "val" )+  , ( NormalTok , " " )+  , ( VariableTok , "blocks" )+  , ( NormalTok+    , " = Array(blocksString.size, { s -> Block(blocksString[s])})"+    )+  ]+, []+, [ ( NormalTok , "            " )+  , ( KeywordTok , "val" )+  , ( NormalTok , " " )+  , ( VariableTok , "words" )+  , ( NormalTok , " = array(" )+  , ( StringTok , "\"\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"A\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"BARK\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"book\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"treat\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"COMMON\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"SQuAd\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"CONFUSE\"" )+  , ( NormalTok , ");" )+  ]+, []+, [ ( NormalTok , "            " )+  , ( ControlFlowTok , "for" )+  , ( NormalTok , " (word " )+  , ( KeywordTok , "in" )+  , ( NormalTok , " words) {" )+  ]+, [ ( NormalTok , "                System." )+  , ( KeywordTok , "out" )+  , ( NormalTok , ".println(" )+  , ( StringTok , "\"${word}: \"" )+  , ( NormalTok , " + canMakeWord(" )+  , ( StringTok , "\"${word}\"" )+  , ( NormalTok , ", blocks))" )+  ]+, [ ( NormalTok , "            }" ) ]+, []+, [ ( NormalTok , "        }" ) ]+, [ ( NormalTok , "    }" ) ]+, [ ( NormalTok , "}" ) ]+, []+, [ ( KeywordTok , "fun" )+  , ( NormalTok , " " )+  , ( FunctionTok , "main" )+  , ( NormalTok , "(" )+  , ( VariableTok , "args" )+  , ( NormalTok , ": " )+  , ( DataTypeTok , "Array" )+  , ( NormalTok , "<" )+  , ( VariableTok , "String" )+  , ( NormalTok , ">) = ABC.main(args)" )+  ]+]
+ test/expected/abc.lisp.native view
@@ -0,0 +1,72 @@+[ []+, [ ( NormalTok , "(" )+  , ( KeywordTok , "defun" )+  , ( FunctionTok , " word-possible-p " )+  , ( NormalTok , "(word blocks)" )+  ]+, [ ( NormalTok , "  (" )+  , ( KeywordTok , "cond" )+  , ( NormalTok , " " )+  ]+, [ ( NormalTok , "    ((" )+  , ( OperatorTok , "=" )+  , ( NormalTok , " (" )+  , ( KeywordTok , "length" )+  , ( NormalTok , " word) " )+  , ( DecValTok , "0" )+  , ( NormalTok , ") " )+  , ( KeywordTok , "t" )+  , ( NormalTok , ")" )+  ]+, [ ( NormalTok , "    ((" )+  , ( KeywordTok , "null" )+  , ( NormalTok , " blocks) " )+  , ( KeywordTok , "nil" )+  , ( NormalTok , ")" )+  ]+, [ ( NormalTok , "    (" )+  , ( KeywordTok , "t" )+  , ( NormalTok , " (" )+  , ( KeywordTok , "let*" )+  , ( NormalTok , " " )+  ]+, [ ( NormalTok , "         ((c (" )+  , ( KeywordTok , "aref" )+  , ( NormalTok , " word " )+  , ( DecValTok , "0" )+  , ( NormalTok , "))" )+  ]+, [ ( NormalTok , "          (bs (" )+  , ( KeywordTok , "remove-if-not" )+  , ( NormalTok , " #'(" )+  , ( KeywordTok , "lambda" )+  , ( NormalTok , " (b) " )+  ]+, [ ( NormalTok , "                                 (" )+  , ( KeywordTok , "find" )+  , ( NormalTok , " c b " )+  , ( BuiltInTok , ":test" )+  , ( NormalTok , " #'char-equal))" )+  ]+, [ ( NormalTok , "                             blocks)))" ) ]+, [ ( NormalTok , "         (" )+  , ( KeywordTok , "some" )+  , ( NormalTok , " #'identity " )+  ]+, [ ( NormalTok , "               (" )+  , ( KeywordTok , "loop" )+  , ( NormalTok , " for b in bs" )+  ]+, [ ( NormalTok , "                     collect (word-possible-p" )+  ]+, [ ( NormalTok , "                               (" )+  , ( KeywordTok , "subseq" )+  , ( NormalTok , " word " )+  , ( DecValTok , "1" )+  , ( NormalTok , ")" )+  ]+, [ ( NormalTok , "                               (" )+  , ( KeywordTok , "remove" )+  , ( NormalTok , " b blocks))))))))" )+  ]+]
+ test/expected/abc.matlab.native view
@@ -0,0 +1,111 @@+[ [ ( NormalTok , "function testABC" ) ]+, [ ( NormalTok , "    combos = [" )+  , ( StringTok , "'BO'" )+  , ( NormalTok , " ; " )+  , ( StringTok , "'XK'" )+  , ( NormalTok , " ; " )+  , ( StringTok , "'DQ'" )+  , ( NormalTok , " ; " )+  , ( StringTok , "'CP'" )+  , ( NormalTok , " ; " )+  , ( StringTok , "'NA'" )+  , ( NormalTok , " ; " )+  , ( StringTok , "'GT'" )+  , ( NormalTok , " ; " )+  , ( StringTok , "'RE'" )+  , ( NormalTok , " ; " )+  , ( StringTok , "'TG'" )+  , ( NormalTok , " ; " )+  , ( StringTok , "'QD'" )+  , ( NormalTok , " ; ..." )+  ]+, [ ( NormalTok , "        " )+  , ( StringTok , "'FS'" )+  , ( NormalTok , " ; " )+  , ( StringTok , "'JW'" )+  , ( NormalTok , " ; " )+  , ( StringTok , "'HU'" )+  , ( NormalTok , " ; " )+  , ( StringTok , "'VI'" )+  , ( NormalTok , " ; " )+  , ( StringTok , "'AN'" )+  , ( NormalTok , " ; " )+  , ( StringTok , "'OB'" )+  , ( NormalTok , " ; " )+  , ( StringTok , "'ER'" )+  , ( NormalTok , " ; " )+  , ( StringTok , "'FS'" )+  , ( NormalTok , " ; " )+  , ( StringTok , "'LY'" )+  , ( NormalTok , " ; ..." )+  ]+, [ ( NormalTok , "        " )+  , ( StringTok , "'PC'" )+  , ( NormalTok , " ; " )+  , ( StringTok , "'ZM'" )+  , ( NormalTok , "];" )+  ]+, [ ( NormalTok , "    words = {" )+  , ( StringTok , "'A'" )+  , ( NormalTok , " " )+  , ( StringTok , "'BARK'" )+  , ( NormalTok , " " )+  , ( StringTok , "'BOOK'" )+  , ( NormalTok , " " )+  , ( StringTok , "'TREAT'" )+  , ( NormalTok , " " )+  , ( StringTok , "'COMMON'" )+  , ( NormalTok , " " )+  , ( StringTok , "'SQUAD'" )+  , ( NormalTok , " " )+  , ( StringTok , "'CONFUSE'" )+  , ( NormalTok , "};" )+  ]+, [ ( NormalTok , "    for k = " )+  , ( FloatTok , "1" )+  , ( NormalTok , ":length(words)" )+  ]+, [ ( NormalTok+    , "        possible = canMakeWord(words{k}, combos);"+    )+  ]+, [ ( NormalTok , "        fprintf(" )+  , ( StringTok , "'Can%s make word %s.\\n'" )+  , ( NormalTok , ", char(~possible.*" )+  , ( StringTok , "'NOT'" )+  , ( NormalTok , "), words{k})" )+  ]+, [ ( NormalTok , "    end" ) ]+, [ ( NormalTok , "end" ) ]+, []+, [ ( NormalTok+    , "function isPossible = canMakeWord(word, combos)"+    )+  ]+, [ ( NormalTok , "    word = lower(word);" ) ]+, [ ( NormalTok , "    combos = lower(combos);" ) ]+, [ ( NormalTok , "    isPossible = true;" ) ]+, [ ( NormalTok , "    k = " )+  , ( FloatTok , "1" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "    while isPossible && k <= length(word)" ) ]+, [ ( NormalTok , "        [r, c] = find(combos == word(k), " )+  , ( FloatTok , "1" )+  , ( NormalTok , ");" )+  ]+, [ ( NormalTok , "        if ~isempty(r)" ) ]+, [ ( NormalTok , "            combos(r, :) = " )+  , ( StringTok , "''" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "        else" ) ]+, [ ( NormalTok , "            isPossible = false;" ) ]+, [ ( NormalTok , "        end" ) ]+, [ ( NormalTok , "        k = k+" )+  , ( FloatTok , "1" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "    end" ) ]+, [ ( NormalTok , "end" ) ]+]
+ test/expected/abc.ocaml.native view
@@ -0,0 +1,228 @@+[ [ ( KeywordTok , "let" ) , ( NormalTok , " blocks = [" ) ]+, [ ( NormalTok , "  (" )+  , ( CharTok , "'B'" )+  , ( NormalTok , ", " )+  , ( CharTok , "'O'" )+  , ( NormalTok , ");  (" )+  , ( CharTok , "'X'" )+  , ( NormalTok , ", " )+  , ( CharTok , "'K'" )+  , ( NormalTok , ");  (" )+  , ( CharTok , "'D'" )+  , ( NormalTok , ", " )+  , ( CharTok , "'Q'" )+  , ( NormalTok , ");  (" )+  , ( CharTok , "'C'" )+  , ( NormalTok , ", " )+  , ( CharTok , "'P'" )+  , ( NormalTok , ");" )+  ]+, [ ( NormalTok , "  (" )+  , ( CharTok , "'N'" )+  , ( NormalTok , ", " )+  , ( CharTok , "'A'" )+  , ( NormalTok , ");  (" )+  , ( CharTok , "'G'" )+  , ( NormalTok , ", " )+  , ( CharTok , "'T'" )+  , ( NormalTok , ");  (" )+  , ( CharTok , "'R'" )+  , ( NormalTok , ", " )+  , ( CharTok , "'E'" )+  , ( NormalTok , ");  (" )+  , ( CharTok , "'T'" )+  , ( NormalTok , ", " )+  , ( CharTok , "'G'" )+  , ( NormalTok , ");" )+  ]+, [ ( NormalTok , "  (" )+  , ( CharTok , "'Q'" )+  , ( NormalTok , ", " )+  , ( CharTok , "'D'" )+  , ( NormalTok , ");  (" )+  , ( CharTok , "'F'" )+  , ( NormalTok , ", " )+  , ( CharTok , "'S'" )+  , ( NormalTok , ");  (" )+  , ( CharTok , "'J'" )+  , ( NormalTok , ", " )+  , ( CharTok , "'W'" )+  , ( NormalTok , ");  (" )+  , ( CharTok , "'H'" )+  , ( NormalTok , ", " )+  , ( CharTok , "'U'" )+  , ( NormalTok , ");" )+  ]+, [ ( NormalTok , "  (" )+  , ( CharTok , "'V'" )+  , ( NormalTok , ", " )+  , ( CharTok , "'I'" )+  , ( NormalTok , ");  (" )+  , ( CharTok , "'A'" )+  , ( NormalTok , ", " )+  , ( CharTok , "'N'" )+  , ( NormalTok , ");  (" )+  , ( CharTok , "'O'" )+  , ( NormalTok , ", " )+  , ( CharTok , "'B'" )+  , ( NormalTok , ");  (" )+  , ( CharTok , "'E'" )+  , ( NormalTok , ", " )+  , ( CharTok , "'R'" )+  , ( NormalTok , ");" )+  ]+, [ ( NormalTok , "  (" )+  , ( CharTok , "'F'" )+  , ( NormalTok , ", " )+  , ( CharTok , "'S'" )+  , ( NormalTok , ");  (" )+  , ( CharTok , "'L'" )+  , ( NormalTok , ", " )+  , ( CharTok , "'Y'" )+  , ( NormalTok , ");  (" )+  , ( CharTok , "'P'" )+  , ( NormalTok , ", " )+  , ( CharTok , "'C'" )+  , ( NormalTok , ");  (" )+  , ( CharTok , "'Z'" )+  , ( NormalTok , ", " )+  , ( CharTok , "'M'" )+  , ( NormalTok , ");" )+  ]+, [ ( NormalTok , "]" ) ]+, []+, [ ( KeywordTok , "let" )+  , ( NormalTok , " find_letter blocks c =" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "let" )+  , ( NormalTok , " found, remaining =" )+  ]+, [ ( NormalTok , "    " )+  , ( DataTypeTok , "List" )+  , ( NormalTok , ".partition (" )+  , ( KeywordTok , "fun" )+  , ( NormalTok , " (c1, c2) -> c1 = c || c2 = c) blocks" )+  ]+, [ ( NormalTok , "  " ) , ( KeywordTok , "in" ) ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "match" )+  , ( NormalTok , " found " )+  , ( KeywordTok , "with" )+  ]+, [ ( NormalTok , "  | _ :: res -> " )+  , ( DataTypeTok , "Some" )+  , ( NormalTok , " (res @ remaining)" )+  ]+, [ ( NormalTok , "  | _ -> " ) , ( DataTypeTok , "None" ) ]+, []+, [ ( KeywordTok , "let" ) , ( NormalTok , " can_make_word w =" ) ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "let" )+  , ( NormalTok , " n = " )+  , ( DataTypeTok , "String" )+  , ( NormalTok , ".length w " )+  , ( KeywordTok , "in" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "let" )+  , ( NormalTok , " " )+  , ( KeywordTok , "rec" )+  , ( NormalTok , " aux i _blocks =" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " i >= n " )+  , ( KeywordTok , "then" )+  , ( NormalTok , " " )+  , ( KeywordTok , "true" )+  , ( NormalTok , " " )+  , ( KeywordTok , "else" )+  ]+, [ ( NormalTok , "      " )+  , ( KeywordTok , "match" )+  , ( NormalTok , " find_letter _blocks w.[i] " )+  , ( KeywordTok , "with" )+  ]+, [ ( NormalTok , "      | " )+  , ( DataTypeTok , "None" )+  , ( NormalTok , " -> " )+  , ( KeywordTok , "false" )+  ]+, [ ( NormalTok , "      | " )+  , ( DataTypeTok , "Some" )+  , ( NormalTok , " rem_blocks ->" )+  ]+, [ ( NormalTok , "          aux (" )+  , ( DataTypeTok , "succ" )+  , ( NormalTok , " i) rem_blocks" )+  ]+, [ ( NormalTok , "  " ) , ( KeywordTok , "in" ) ]+, [ ( NormalTok , "  aux " )+  , ( DecValTok , "0" )+  , ( NormalTok , " blocks" )+  ]+, []+, [ ( KeywordTok , "let" )+  , ( NormalTok , " test label f (word, should) =" )+  ]+, [ ( NormalTok , "  " )+  , ( DataTypeTok , "Printf" )+  , ( NormalTok , ".printf " )+  , ( StringTok , "\"- %s %S = %B  (should: %B)" )+  , ( CharTok , "\\n" )+  , ( StringTok , "\"" )+  , ( NormalTok , " label word (f word) should" )+  ]+, []+, [ ( KeywordTok , "let" ) , ( NormalTok , " () =" ) ]+, [ ( NormalTok , "  " )+  , ( DataTypeTok , "List" )+  , ( NormalTok , ".iter (test " )+  , ( StringTok , "\"can make word\"" )+  , ( NormalTok , " can_make_word) [" )+  ]+, [ ( NormalTok , "    " )+  , ( StringTok , "\"A\"" )+  , ( NormalTok , ", " )+  , ( KeywordTok , "true" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "    " )+  , ( StringTok , "\"BARK\"" )+  , ( NormalTok , ", " )+  , ( KeywordTok , "true" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "    " )+  , ( StringTok , "\"BOOK\"" )+  , ( NormalTok , ", " )+  , ( KeywordTok , "false" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "    " )+  , ( StringTok , "\"TREAT\"" )+  , ( NormalTok , ", " )+  , ( KeywordTok , "true" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "    " )+  , ( StringTok , "\"COMMON\"" )+  , ( NormalTok , ", " )+  , ( KeywordTok , "false" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "    " )+  , ( StringTok , "\"SQUAD\"" )+  , ( NormalTok , ", " )+  , ( KeywordTok , "true" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "    " )+  , ( StringTok , "\"CONFUSE\"" )+  , ( NormalTok , ", " )+  , ( KeywordTok , "true" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "  ]" ) ]+]
+ test/expected/abc.perl.native view
@@ -0,0 +1,111 @@+[ [ ( FunctionTok , "use" )+  , ( NormalTok , " " )+  , ( FunctionTok , "Test::More" )+  , ( NormalTok , " tests => " )+  , ( DecValTok , "8" )+  , ( NormalTok , ";" )+  ]+, []+, [ ( KeywordTok , "my" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "@blocks1" )+  , ( NormalTok , " = " )+  , ( KeywordTok , "qw(" )+  , ( NormalTok+    , "BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM"+    )+  , ( KeywordTok , ")" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "is(can_make_word(" )+  , ( KeywordTok , "\"" )+  , ( StringTok , "A" )+  , ( KeywordTok , "\"" )+  , ( NormalTok , ",       " )+  , ( DataTypeTok , "@blocks1" )+  , ( NormalTok , "), " )+  , ( DecValTok , "1" )+  , ( NormalTok , ");" )+  ]+, [ ( NormalTok , "is(can_make_word(" )+  , ( KeywordTok , "\"" )+  , ( StringTok , "BARK" )+  , ( KeywordTok , "\"" )+  , ( NormalTok , ",    " )+  , ( DataTypeTok , "@blocks1" )+  , ( NormalTok , "), " )+  , ( DecValTok , "1" )+  , ( NormalTok , ");" )+  ]+, [ ( NormalTok , "is(can_make_word(" )+  , ( KeywordTok , "\"" )+  , ( StringTok , "BOOK" )+  , ( KeywordTok , "\"" )+  , ( NormalTok , ",    " )+  , ( DataTypeTok , "@blocks1" )+  , ( NormalTok , "), " )+  , ( FunctionTok , "undef" )+  , ( NormalTok , ");" )+  ]+, [ ( NormalTok , "is(can_make_word(" )+  , ( KeywordTok , "\"" )+  , ( StringTok , "TREAT" )+  , ( KeywordTok , "\"" )+  , ( NormalTok , ",   " )+  , ( DataTypeTok , "@blocks1" )+  , ( NormalTok , "), " )+  , ( DecValTok , "1" )+  , ( NormalTok , ");" )+  ]+, [ ( NormalTok , "is(can_make_word(" )+  , ( KeywordTok , "\"" )+  , ( StringTok , "COMMON" )+  , ( KeywordTok , "\"" )+  , ( NormalTok , ",  " )+  , ( DataTypeTok , "@blocks1" )+  , ( NormalTok , "), " )+  , ( FunctionTok , "undef" )+  , ( NormalTok , ");" )+  ]+, [ ( NormalTok , "is(can_make_word(" )+  , ( KeywordTok , "\"" )+  , ( StringTok , "SQUAD" )+  , ( KeywordTok , "\"" )+  , ( NormalTok , ",   " )+  , ( DataTypeTok , "@blocks1" )+  , ( NormalTok , "), " )+  , ( DecValTok , "1" )+  , ( NormalTok , ");" )+  ]+, [ ( NormalTok , "is(can_make_word(" )+  , ( KeywordTok , "\"" )+  , ( StringTok , "CONFUSE" )+  , ( KeywordTok , "\"" )+  , ( NormalTok , ", " )+  , ( DataTypeTok , "@blocks1" )+  , ( NormalTok , "), " )+  , ( DecValTok , "1" )+  , ( NormalTok , ");" )+  ]+, []+, [ ( KeywordTok , "my" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "@blocks2" )+  , ( NormalTok , " = " )+  , ( KeywordTok , "qw(" )+  , ( NormalTok , "US TZ AO QA" )+  , ( KeywordTok , ")" )+  , ( NormalTok , ";" )+  ]+, [ ( NormalTok , "is(can_make_word(" )+  , ( KeywordTok , "'" )+  , ( StringTok , "auto" )+  , ( KeywordTok , "'" )+  , ( NormalTok , ", " )+  , ( DataTypeTok , "@blocks2" )+  , ( NormalTok , "), " )+  , ( DecValTok , "1" )+  , ( NormalTok , ");" )+  ]+, []+]
+ test/expected/abc.php.native view
@@ -0,0 +1,236 @@+[ []+, [ ( KeywordTok , "<?php" ) ]+, [ ( KeywordTok , "$words" )+  , ( NormalTok , " = " )+  , ( FunctionTok , "array" )+  , ( OtherTok , "(" )+  , ( StringTok , "\"A\"" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( StringTok , "\"BARK\"" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( StringTok , "\"BOOK\"" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( StringTok , "\"TREAT\"" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( StringTok , "\"COMMON\"" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( StringTok , "\"SQUAD\"" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( StringTok , "\"Confuse\"" )+  , ( OtherTok , ");" )+  ]+, []+, [ ( KeywordTok , "function" )+  , ( NormalTok , " canMakeWord" )+  , ( OtherTok , "(" )+  , ( KeywordTok , "$word" )+  , ( OtherTok , ")" )+  , ( NormalTok , " {" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "$word" )+  , ( NormalTok , " = " )+  , ( FunctionTok , "strtoupper" )+  , ( OtherTok , "(" )+  , ( KeywordTok , "$word" )+  , ( OtherTok , ");" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "$blocks" )+  , ( NormalTok , " = " )+  , ( FunctionTok , "array" )+  , ( OtherTok , "(" )+  ]+, [ ( NormalTok , "            " )+  , ( StringTok , "\"BO\"" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( StringTok , "\"XK\"" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( StringTok , "\"DQ\"" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( StringTok , "\"CP\"" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( StringTok , "\"NA\"" )+  , ( OtherTok , "," )+  ]+, [ ( NormalTok , "            " )+  , ( StringTok , "\"GT\"" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( StringTok , "\"RE\"" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( StringTok , "\"TG\"" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( StringTok , "\"QD\"" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( StringTok , "\"FS\"" )+  , ( OtherTok , "," )+  ]+, [ ( NormalTok , "            " )+  , ( StringTok , "\"JW\"" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( StringTok , "\"HU\"" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( StringTok , "\"VI\"" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( StringTok , "\"AN\"" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( StringTok , "\"OB\"" )+  , ( OtherTok , "," )+  ]+, [ ( NormalTok , "            " )+  , ( StringTok , "\"ER\"" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( StringTok , "\"FS\"" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( StringTok , "\"LY\"" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( StringTok , "\"PC\"" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( StringTok , "\"ZM\"" )+  , ( OtherTok , "," )+  ]+, [ ( NormalTok , "    " ) , ( OtherTok , ");" ) ]+, []+, [ ( NormalTok , "    " )+  , ( KeywordTok , "foreach" )+  , ( NormalTok , " " )+  , ( OtherTok , "(" )+  , ( FunctionTok , "str_split" )+  , ( OtherTok , "(" )+  , ( KeywordTok , "$word" )+  , ( OtherTok , ")" )+  , ( NormalTok , " " )+  , ( KeywordTok , "as" )+  , ( NormalTok , " " )+  , ( KeywordTok , "$char" )+  , ( OtherTok , ")" )+  , ( NormalTok , " {" )+  ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "foreach" )+  , ( NormalTok , " " )+  , ( OtherTok , "(" )+  , ( KeywordTok , "$blocks" )+  , ( NormalTok , " " )+  , ( KeywordTok , "as" )+  , ( NormalTok , " " )+  , ( KeywordTok , "$k" )+  , ( NormalTok , " => " )+  , ( KeywordTok , "$block" )+  , ( OtherTok , ")" )+  , ( NormalTok , " {" )+  ]+, [ ( NormalTok , "            " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " " )+  , ( OtherTok , "(" )+  , ( FunctionTok , "strpos" )+  , ( OtherTok , "(" )+  , ( KeywordTok , "$block" )+  , ( OtherTok , "," )+  , ( NormalTok , " " )+  , ( KeywordTok , "$char" )+  , ( OtherTok , ")" )+  , ( NormalTok , " !== " )+  , ( KeywordTok , "FALSE" )+  , ( OtherTok , ")" )+  , ( NormalTok , " {" )+  ]+, [ ( NormalTok , "                " )+  , ( FunctionTok , "unset" )+  , ( OtherTok , "(" )+  , ( KeywordTok , "$blocks" )+  , ( OtherTok , "[" )+  , ( KeywordTok , "$k" )+  , ( OtherTok , "]);" )+  ]+, [ ( NormalTok , "                " )+  , ( KeywordTok , "continue" )+  , ( OtherTok , "(" )+  , ( DecValTok , "2" )+  , ( OtherTok , ");" )+  ]+, [ ( NormalTok , "            }" ) ]+, [ ( NormalTok , "        }" ) ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( KeywordTok , "false" )+  , ( OtherTok , ";" )+  ]+, [ ( NormalTok , "    }" ) ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( KeywordTok , "true" )+  , ( OtherTok , ";" )+  ]+, [ ( NormalTok , "}" ) ]+, []+, [ ( KeywordTok , "foreach" )+  , ( NormalTok , " " )+  , ( OtherTok , "(" )+  , ( KeywordTok , "$words" )+  , ( NormalTok , " " )+  , ( KeywordTok , "as" )+  , ( NormalTok , " " )+  , ( KeywordTok , "$word" )+  , ( OtherTok , ")" )+  , ( NormalTok , " {" )+  ]+, [ ( NormalTok , "    " )+  , ( FunctionTok , "echo" )+  , ( NormalTok , " " )+  , ( KeywordTok , "$word" )+  , ( NormalTok , "." )+  , ( StringTok , "': '" )+  , ( OtherTok , ";" )+  ]+, [ ( NormalTok , "    " )+  , ( FunctionTok , "echo" )+  , ( NormalTok , " canMakeWord" )+  , ( OtherTok , "(" )+  , ( KeywordTok , "$word" )+  , ( OtherTok , ")" )+  , ( NormalTok , " " )+  , ( OtherTok , "?" )+  , ( NormalTok , " " )+  , ( StringTok , "\"True\"" )+  , ( NormalTok , " " )+  , ( OtherTok , ":" )+  , ( NormalTok , " " )+  , ( StringTok , "\"False\"" )+  , ( OtherTok , ";" )+  ]+, [ ( NormalTok , "    " )+  , ( FunctionTok , "echo" )+  , ( NormalTok , " " )+  , ( StringTok , "\"" )+  , ( KeywordTok , "\\r\\n" )+  , ( StringTok , "\"" )+  , ( OtherTok , ";" )+  ]+, [ ( NormalTok , "}" ) ]+]
+ test/expected/abc.prolog.native view
@@ -0,0 +1,163 @@+[ [ ( NormalTok , "abc_problem " ) , ( KeywordTok , ":-" ) ]+, [ ( NormalTok , "        maplist(abc_problem" )+  , ( KeywordTok , "," )+  , ( NormalTok , " ['', '" )+  , ( ErrorTok , "A" )+  , ( NormalTok , "', bark, bOOk, treAT, '" )+  , ( ErrorTok , "COmmon" )+  , ( NormalTok , "', sQuaD, '" )+  , ( ErrorTok , "CONFUSE" )+  , ( NormalTok , "'])" )+  , ( KeywordTok , "." )+  ]+, []+, []+, [ ( NormalTok , "abc_problem(" )+  , ( DataTypeTok , "Word" )+  , ( NormalTok , ") " )+  , ( KeywordTok , ":-" )+  ]+, [ ( NormalTok , "        " )+  , ( DataTypeTok , "L" )+  , ( NormalTok , " " )+  , ( KeywordTok , "=" )+  , ( NormalTok+    , " [[b,o],[x,k],[d,q],[c,p],[n,a],[g,t],[r,e],[t,g],[q,d],[f,s],"+    )+  ]+, [ ( NormalTok+    , "             [j,w],[h,u],[v,i],[a,n],[o,b],[e,r],[f,s],[l,y],[p,c],[z,m]]"+    )+  , ( KeywordTok , "," )+  ]+, []+, [ ( NormalTok , "        (   abc_problem(" )+  , ( DataTypeTok , "L" )+  , ( KeywordTok , "," )+  , ( NormalTok , " " )+  , ( DataTypeTok , "Word" )+  , ( NormalTok , ")" )+  ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "->" )+  , ( NormalTok , "  format('~" )+  , ( ErrorTok , "w" )+  , ( AlertTok , " " )+  , ( ErrorTok , "OK" )+  , ( NormalTok , "~" )+  , ( ErrorTok , "n" )+  , ( NormalTok , "'" )+  , ( KeywordTok , "," )+  , ( NormalTok , " [" )+  , ( DataTypeTok , "Word" )+  , ( NormalTok , "])" )+  ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , ";" )+  , ( NormalTok , "   format('~" )+  , ( ErrorTok , "w" )+  , ( AlertTok , " " )+  , ( ErrorTok , "KO" )+  , ( NormalTok , "~" )+  , ( ErrorTok , "n" )+  , ( NormalTok , "'" )+  , ( KeywordTok , "," )+  , ( NormalTok , " [" )+  , ( DataTypeTok , "Word" )+  , ( NormalTok , "]))" )+  , ( KeywordTok , "." )+  ]+, []+, [ ( NormalTok , "abc_problem(" )+  , ( DataTypeTok , "L" )+  , ( KeywordTok , "," )+  , ( NormalTok , " " )+  , ( DataTypeTok , "Word" )+  , ( NormalTok , ") " )+  , ( KeywordTok , ":-" )+  ]+, [ ( NormalTok , "        " )+  , ( FunctionTok , "atom_chars" )+  , ( NormalTok , "(" )+  , ( DataTypeTok , "Word" )+  , ( KeywordTok , "," )+  , ( NormalTok , " " )+  , ( DataTypeTok , "C_Words" )+  , ( NormalTok , ")" )+  , ( KeywordTok , "," )+  ]+, [ ( NormalTok , "        maplist(downcase_atom" )+  , ( KeywordTok , "," )+  , ( NormalTok , " " )+  , ( DataTypeTok , "C_Words" )+  , ( KeywordTok , "," )+  , ( NormalTok , " " )+  , ( DataTypeTok , "D_Words" )+  , ( NormalTok , ")" )+  , ( KeywordTok , "," )+  ]+, [ ( NormalTok , "        can_makeword(" )+  , ( DataTypeTok , "L" )+  , ( KeywordTok , "," )+  , ( NormalTok , " " )+  , ( DataTypeTok , "D_Words" )+  , ( NormalTok , ")" )+  , ( KeywordTok , "." )+  ]+, []+, [ ( NormalTok , "can_makeword(" )+  , ( DataTypeTok , "_L" )+  , ( KeywordTok , "," )+  , ( NormalTok , " [])" )+  , ( KeywordTok , "." )+  ]+, []+, [ ( NormalTok , "can_makeword(" )+  , ( DataTypeTok , "L" )+  , ( KeywordTok , "," )+  , ( NormalTok , " [" )+  , ( DataTypeTok , "H" )+  , ( NormalTok , " " )+  , ( FunctionTok , "|" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "T" )+  , ( NormalTok , "]) " )+  , ( KeywordTok , ":-" )+  ]+, [ ( NormalTok , "        (   select([" )+  , ( DataTypeTok , "H" )+  , ( NormalTok , ", " )+  , ( DataTypeTok , "_" )+  , ( NormalTok , "]" )+  , ( KeywordTok , "," )+  , ( NormalTok , " " )+  , ( DataTypeTok , "L" )+  , ( KeywordTok , "," )+  , ( NormalTok , " " )+  , ( DataTypeTok , "L1" )+  , ( NormalTok , ")" )+  , ( KeywordTok , ";" )+  , ( NormalTok , " select([" )+  , ( DataTypeTok , "_" )+  , ( NormalTok , ", " )+  , ( DataTypeTok , "H" )+  , ( NormalTok , "]" )+  , ( KeywordTok , "," )+  , ( NormalTok , " " )+  , ( DataTypeTok , "L" )+  , ( KeywordTok , "," )+  , ( NormalTok , " " )+  , ( DataTypeTok , "L1" )+  , ( NormalTok , "))" )+  , ( KeywordTok , "," )+  ]+, [ ( NormalTok , "        can_makeword(" )+  , ( DataTypeTok , "L1" )+  , ( KeywordTok , "," )+  , ( NormalTok , " " )+  , ( DataTypeTok , "T" )+  , ( NormalTok , ")" )+  , ( KeywordTok , "." )+  ]+, []+]
+ test/expected/abc.python.native view
@@ -0,0 +1,108 @@+[ [ ( KeywordTok , "def" ) , ( NormalTok , " mkword(w, b):" ) ]+, [ ( NormalTok , "    " )+  , ( ControlFlowTok , "if" )+  , ( NormalTok , " " )+  , ( KeywordTok , "not" )+  , ( NormalTok , " w: " )+  , ( ControlFlowTok , "return" )+  , ( NormalTok , " []" )+  ]+, []+, [ ( NormalTok , "    c,w " )+  , ( OperatorTok , "=" )+  , ( NormalTok , " w[" )+  , ( DecValTok , "0" )+  , ( NormalTok , "],w[" )+  , ( DecValTok , "1" )+  , ( NormalTok , ":]" )+  ]+, [ ( NormalTok , "    " )+  , ( ControlFlowTok , "for" )+  , ( NormalTok , " i " )+  , ( KeywordTok , "in" )+  , ( NormalTok , " " )+  , ( BuiltInTok , "range" )+  , ( NormalTok , "(" )+  , ( BuiltInTok , "len" )+  , ( NormalTok , "(b)):" )+  ]+, [ ( NormalTok , "        " )+  , ( ControlFlowTok , "if" )+  , ( NormalTok , " c " )+  , ( KeywordTok , "in" )+  , ( NormalTok , " b[i]:" )+  ]+, [ ( NormalTok , "            m " )+  , ( OperatorTok , "=" )+  , ( NormalTok , " mkword(w, b[" )+  , ( DecValTok , "0" )+  , ( NormalTok , ":i] " )+  , ( OperatorTok , "+" )+  , ( NormalTok , " b[i" )+  , ( DecValTok , "+1" )+  , ( NormalTok , ":])" )+  ]+, [ ( NormalTok , "            " )+  , ( ControlFlowTok , "if" )+  , ( NormalTok , " m " )+  , ( OperatorTok , "!=" )+  , ( NormalTok , " " )+  , ( VariableTok , "None" )+  , ( NormalTok , ": " )+  , ( ControlFlowTok , "return" )+  , ( NormalTok , " [b[i]] " )+  , ( OperatorTok , "+" )+  , ( NormalTok , " m" )+  ]+, []+, [ ( KeywordTok , "def" ) , ( NormalTok , " abc(w, blk):" ) ]+, [ ( NormalTok , "    " )+  , ( ControlFlowTok , "return" )+  , ( NormalTok , " mkword(w.upper(), [a.upper() " )+  , ( ControlFlowTok , "for" )+  , ( NormalTok , " a " )+  , ( KeywordTok , "in" )+  , ( NormalTok , " blk])" )+  ]+, []+, [ ( NormalTok , "blocks " )+  , ( OperatorTok , "=" )+  , ( NormalTok , " " )+  , ( StringTok+    , "'BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM'"+    )+  , ( NormalTok , ".split()" )+  ]+, []+, [ ( ControlFlowTok , "for" )+  , ( NormalTok , " w " )+  , ( KeywordTok , "in" )+  , ( NormalTok , " " )+  , ( StringTok+    , "\", A, bark, book, treat, common, SQUAD, conFUsEd\""+    )+  , ( NormalTok , ".split(" )+  , ( StringTok , "', '" )+  , ( NormalTok , "):" )+  ]+, [ ( NormalTok , "    " )+  , ( BuiltInTok , "print" )+  , ( NormalTok , " " )+  , ( StringTok , "'" )+  , ( CharTok , "\\'" )+  , ( StringTok , "'" )+  , ( NormalTok , " " )+  , ( OperatorTok , "+" )+  , ( NormalTok , " w " )+  , ( OperatorTok , "+" )+  , ( NormalTok , " " )+  , ( StringTok , "'" )+  , ( CharTok , "\\'" )+  , ( StringTok , "'" )+  , ( NormalTok , " " )+  , ( OperatorTok , "+" )+  , ( NormalTok , " " )+  , ( StringTok , "' ->'" )+  , ( NormalTok , ", abc(w, blocks)" )+  ]+]
+ test/expected/abc.r.native view
@@ -0,0 +1,140 @@+[ [ ( NormalTok , "canMakeNoRecursion <-" )+  , ( StringTok , " " )+  , ( ControlFlowTok , "function" )+  , ( NormalTok , "(x) {" )+  ]+, [ ( NormalTok , "  x <-" )+  , ( StringTok , " " )+  , ( KeywordTok , "toupper" )+  , ( NormalTok , "(x)" )+  ]+, [ ( NormalTok , "  charList <-" )+  , ( StringTok , " " )+  , ( KeywordTok , "strsplit" )+  , ( NormalTok , "(x, " )+  , ( KeywordTok , "character" )+  , ( NormalTok , "(" )+  , ( DecValTok , "0" )+  , ( NormalTok , "))" )+  ]+, [ ( NormalTok , "  getCombos <-" )+  , ( StringTok , " " )+  , ( ControlFlowTok , "function" )+  , ( NormalTok , "(chars) {" )+  ]+, [ ( NormalTok , "    charBlocks <-" )+  , ( StringTok , "  " )+  , ( KeywordTok , "data.matrix" )+  , ( NormalTok , "(" )+  , ( KeywordTok , "expand.grid" )+  , ( NormalTok , "(" )+  , ( KeywordTok , "lapply" )+  , ( NormalTok , "(chars, " )+  , ( ControlFlowTok , "function" )+  , ( NormalTok , "(char) " )+  , ( KeywordTok , "which" )+  , ( NormalTok , "(blocks " )+  , ( OperatorTok , "==" )+  , ( StringTok , " " )+  , ( NormalTok , "char, " )+  , ( DataTypeTok , "arr.ind=" )+  , ( OtherTok , "TRUE" )+  , ( NormalTok , ")[, 1L])))" )+  ]+, [ ( NormalTok , "    charBlocks <-" )+  , ( StringTok , " " )+  , ( NormalTok , "charBlocks[" )+  , ( OperatorTok , "!" )+  , ( KeywordTok , "apply" )+  , ( NormalTok , "(charBlocks, " )+  , ( DecValTok , "1" )+  , ( NormalTok , ", " )+  , ( ControlFlowTok , "function" )+  , ( NormalTok , "(row) " )+  , ( KeywordTok , "any" )+  , ( NormalTok , "(" )+  , ( KeywordTok , "duplicated" )+  , ( NormalTok , "(row))), , drop=" )+  , ( OtherTok , "FALSE" )+  , ( NormalTok , "]" )+  ]+, [ ( NormalTok , "    " )+  , ( ControlFlowTok , "if" )+  , ( NormalTok , " (" )+  , ( KeywordTok , "dim" )+  , ( NormalTok , "(charBlocks)[1L] " )+  , ( OperatorTok , ">" )+  , ( StringTok , " " )+  , ( NormalTok , "0L) {" )+  ]+, [ ( NormalTok , "      " )+  , ( KeywordTok , "t" )+  , ( NormalTok , "(" )+  , ( KeywordTok , "apply" )+  , ( NormalTok , "(charBlocks, " )+  , ( DecValTok , "1" )+  , ( NormalTok , ", " )+  , ( ControlFlowTok , "function" )+  , ( NormalTok , "(row) " )+  , ( KeywordTok , "apply" )+  , ( NormalTok , "(blocks[row, , " )+  , ( DataTypeTok , "drop=" )+  , ( OtherTok , "FALSE" )+  , ( NormalTok , "], " )+  , ( DecValTok , "1" )+  , ( NormalTok , ", paste, " )+  , ( DataTypeTok , "collapse=" )+  , ( StringTok , "\"\"" )+  , ( NormalTok , ")))" )+  ]+, [ ( NormalTok , "    } " )+  , ( ControlFlowTok , "else" )+  , ( NormalTok , " {" )+  ]+, [ ( NormalTok , "      " )+  , ( KeywordTok , "character" )+  , ( NormalTok , "(" )+  , ( DecValTok , "0" )+  , ( NormalTok , ")" )+  ]+, [ ( NormalTok , "    }" ) ]+, [ ( NormalTok , "  }" ) ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "setNames" )+  , ( NormalTok , "(" )+  , ( KeywordTok , "lapply" )+  , ( NormalTok , "(charList, getCombos), x)" )+  ]+, [ ( NormalTok , "}" ) ]+, [ ( KeywordTok , "canMakeNoRecursion" )+  , ( NormalTok , "(" )+  , ( KeywordTok , "c" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"A\"" )+  , ( NormalTok , "," )+  ]+, [ ( NormalTok , "           " )+  , ( StringTok , "\"BARK\"" )+  , ( NormalTok , "," )+  ]+, [ ( NormalTok , "           " )+  , ( StringTok , "\"BOOK\"" )+  , ( NormalTok , "," )+  ]+, [ ( NormalTok , "           " )+  , ( StringTok , "\"TREAT\"" )+  , ( NormalTok , "," )+  ]+, [ ( NormalTok , "           " )+  , ( StringTok , "\"COMMON\"" )+  , ( NormalTok , "," )+  ]+, [ ( NormalTok , "           " )+  , ( StringTok , "\"SQUAD\"" )+  , ( NormalTok , "," )+  ]+, [ ( NormalTok , "           " )+  , ( StringTok , "\"CONFUSE\"" )+  , ( NormalTok , "))" )+  ]+]
+ test/expected/abc.ruby.native view
@@ -0,0 +1,40 @@+[ [ ( NormalTok , "words =" )+  , ( OtherTok , " %w(" )+  , ( StringTok , "A BaRK BOoK tREaT COmMOn SqUAD CoNfuSE" )+  , ( OtherTok , ")" )+  , ( NormalTok , " << " )+  , ( StringTok , "\"\"" )+  ]+, []+, [ ( NormalTok , "words.each " )+  , ( KeywordTok , "do" )+  , ( NormalTok , " |word|" )+  ]+, [ ( NormalTok , "  blocks = " )+  , ( StringTok+    , "\"BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM\""+    )+  ]+, [ ( NormalTok , "  res = word.each_char.all?{|c| blocks.sub!(" )+  , ( OtherTok , "/\\w?#{" )+  , ( NormalTok , "c" )+  , ( OtherTok , "}\\w?/i" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"\"" )+  , ( NormalTok , ")}  " )+  , ( CommentTok , "#regexps can be interpolated like strings" )+  ]+, [ ( NormalTok , "  puts " )+  , ( StringTok , "\"" )+  , ( OtherTok , "#{" )+  , ( NormalTok , "word.inspect" )+  , ( OtherTok , "}" )+  , ( StringTok , ": " )+  , ( OtherTok , "#{" )+  , ( NormalTok , "res" )+  , ( OtherTok , "}" )+  , ( StringTok , "\"" )+  ]+, [ ( KeywordTok , "end" ) ]+, []+]
+ test/expected/abc.scala.native view
@@ -0,0 +1,364 @@+[ [ ( KeywordTok , "object" )+  , ( NormalTok , " AbcBlocks " )+  , ( KeywordTok , "extends" )+  , ( NormalTok , " App {" )+  ]+, []+, [ ( NormalTok , "  " )+  , ( KeywordTok , "protected" )+  , ( NormalTok , " " )+  , ( KeywordTok , "class" )+  , ( NormalTok , " " )+  , ( FunctionTok , "Block" )+  , ( NormalTok , "(face1: Char, face2: Char) {" )+  ]+, []+, [ ( NormalTok , "    " )+  , ( KeywordTok , "def" )+  , ( NormalTok , " " )+  , ( FunctionTok , "isFacedWith" )+  , ( NormalTok+    , "(that: Char) = { that == face1 || that == face2 }"+    )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "override" )+  , ( NormalTok , " " )+  , ( KeywordTok , "def" )+  , ( NormalTok , " " )+  , ( FunctionTok , "toString" )+  , ( NormalTok , "() = face1." )+  , ( FunctionTok , "toString" )+  , ( NormalTok , " + face2" )+  ]+, [ ( NormalTok , "  }" ) ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "protected" )+  , ( NormalTok , " " )+  , ( KeywordTok , "object" )+  , ( NormalTok , " Block {" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "def" )+  , ( NormalTok , " " )+  , ( FunctionTok , "apply" )+  , ( NormalTok , "(faces: String) = " )+  , ( KeywordTok , "new" )+  , ( NormalTok , " " )+  , ( FunctionTok , "Block" )+  , ( NormalTok , "(faces." )+  , ( FunctionTok , "head" )+  , ( NormalTok , ", faces." )+  , ( FunctionTok , "last" )+  , ( NormalTok , ")" )+  ]+, [ ( NormalTok , "  }" ) ]+, []+, [ ( NormalTok , "  " )+  , ( KeywordTok , "type" )+  , ( NormalTok , " word = Seq[Block]" )+  ]+, []+, [ ( NormalTok , "  " )+  , ( KeywordTok , "private" )+  , ( NormalTok , " " )+  , ( KeywordTok , "val" )+  , ( NormalTok , " blocks = List(" )+  , ( FunctionTok , "Block" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"BO\"" )+  , ( NormalTok , "), " )+  , ( FunctionTok , "Block" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"XK\"" )+  , ( NormalTok , "), " )+  , ( FunctionTok , "Block" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"DQ\"" )+  , ( NormalTok , "), " )+  , ( FunctionTok , "Block" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"CP\"" )+  , ( NormalTok , "), " )+  , ( FunctionTok , "Block" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"NA\"" )+  , ( NormalTok , ")," )+  ]+, [ ( NormalTok , "    " )+  , ( FunctionTok , "Block" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"GT\"" )+  , ( NormalTok , "), " )+  , ( FunctionTok , "Block" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"RE\"" )+  , ( NormalTok , "), " )+  , ( FunctionTok , "Block" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"TG\"" )+  , ( NormalTok , "), " )+  , ( FunctionTok , "Block" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"QD\"" )+  , ( NormalTok , "), " )+  , ( FunctionTok , "Block" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"FS\"" )+  , ( NormalTok , ")," )+  ]+, [ ( NormalTok , "    " )+  , ( FunctionTok , "Block" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"JW\"" )+  , ( NormalTok , "), " )+  , ( FunctionTok , "Block" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"HU\"" )+  , ( NormalTok , "), " )+  , ( FunctionTok , "Block" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"VI\"" )+  , ( NormalTok , "), " )+  , ( FunctionTok , "Block" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"AN\"" )+  , ( NormalTok , "), " )+  , ( FunctionTok , "Block" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"OB\"" )+  , ( NormalTok , ")," )+  ]+, [ ( NormalTok , "    " )+  , ( FunctionTok , "Block" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"ER\"" )+  , ( NormalTok , "), " )+  , ( FunctionTok , "Block" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"FS\"" )+  , ( NormalTok , "), " )+  , ( FunctionTok , "Block" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"LY\"" )+  , ( NormalTok , "), " )+  , ( FunctionTok , "Block" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"PC\"" )+  , ( NormalTok , "), " )+  , ( FunctionTok , "Block" )+  , ( NormalTok , "(" )+  , ( StringTok , "\"ZM\"" )+  , ( NormalTok , "))" )+  ]+, []+, [ ( NormalTok , "  " )+  , ( KeywordTok , "private" )+  , ( NormalTok , " " )+  , ( KeywordTok , "def" )+  , ( NormalTok , " " )+  , ( FunctionTok , "isMakeable" )+  , ( NormalTok , "(word: String, blocks: word) = {" )+  ]+, []+, [ ( NormalTok , "    " )+  , ( KeywordTok , "def" )+  , ( NormalTok , " " )+  , ( FunctionTok , "getTheBlocks" )+  , ( NormalTok , "(word: String, blocks: word) = {" )+  ]+, []+, [ ( NormalTok , "      " )+  , ( KeywordTok , "def" )+  , ( NormalTok , " " )+  , ( FunctionTok , "inner" )+  , ( NormalTok+    , "(word: String, toCompare: word, rest: word, accu: word): word = {"+    )+  ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " (word." )+  , ( FunctionTok , "isEmpty" )+  , ( NormalTok , " || rest." )+  , ( FunctionTok , "isEmpty" )+  , ( NormalTok , " || toCompare." )+  , ( FunctionTok , "isEmpty" )+  , ( NormalTok , ") accu" )+  ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "else" )+  , ( NormalTok , " " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " (toCompare." )+  , ( FunctionTok , "head" )+  , ( NormalTok , "." )+  , ( FunctionTok , "isFacedWith" )+  , ( NormalTok , "(word." )+  , ( FunctionTok , "head" )+  , ( NormalTok , ")) {" )+  ]+, [ ( NormalTok , "          " )+  , ( KeywordTok , "val" )+  , ( NormalTok , " restant = rest diff List(toCompare." )+  , ( FunctionTok , "head" )+  , ( NormalTok , ")" )+  ]+, [ ( NormalTok , "          " )+  , ( FunctionTok , "inner" )+  , ( NormalTok , "(word." )+  , ( FunctionTok , "tail" )+  , ( NormalTok , ", restant, restant, accu :+ toCompare." )+  , ( FunctionTok , "head" )+  , ( NormalTok , ")" )+  ]+, [ ( NormalTok , "        } " )+  , ( KeywordTok , "else" )+  , ( NormalTok , " " )+  , ( FunctionTok , "inner" )+  , ( NormalTok , "(word, toCompare." )+  , ( FunctionTok , "tail" )+  , ( NormalTok , ", rest, accu)" )+  ]+, [ ( NormalTok , "      }" ) ]+, [ ( NormalTok , "      " )+  , ( FunctionTok , "inner" )+  , ( NormalTok , "(word, blocks, blocks, Nil)" )+  ]+, [ ( NormalTok , "    }" ) ]+, []+, [ ( NormalTok , "    word." )+  , ( FunctionTok , "lengthCompare" )+  , ( NormalTok , "(" )+  , ( FunctionTok , "getTheBlocks" )+  , ( NormalTok , "(word, blocks)." )+  , ( FunctionTok , "size" )+  , ( NormalTok , ") == " )+  , ( DecValTok , "0" )+  ]+, [ ( NormalTok , "  }" ) ]+, []+, [ ( NormalTok , "  " )+  , ( KeywordTok , "val" )+  , ( NormalTok , " words = List(" )+  , ( StringTok , "\"A\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"BARK\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"BOOK\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"TREAT\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"COMMON\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"SQUAD\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"CONFUSED\"" )+  , ( NormalTok , ", " )+  , ( StringTok , "\"ANBOCPDQERSFTGUVWXLZ\"" )+  , ( NormalTok , ")" )+  ]+, [ ( NormalTok , "  " ) , ( CommentTok , "// Automatic tests" ) ]+, [ ( NormalTok , "  " )+  , ( FunctionTok , "assert" )+  , ( NormalTok , "(" )+  , ( FunctionTok , "isMakeable" )+  , ( NormalTok , "(" )+  , ( FunctionTok , "words" )+  , ( NormalTok , "(" )+  , ( DecValTok , "0" )+  , ( NormalTok , "), blocks))" )+  ]+, [ ( NormalTok , "  " )+  , ( FunctionTok , "assert" )+  , ( NormalTok , "(" )+  , ( FunctionTok , "isMakeable" )+  , ( NormalTok , "(" )+  , ( FunctionTok , "words" )+  , ( NormalTok , "(" )+  , ( DecValTok , "1" )+  , ( NormalTok , "), blocks))" )+  ]+, [ ( NormalTok , "  " )+  , ( FunctionTok , "assert" )+  , ( NormalTok , "(!" )+  , ( FunctionTok , "isMakeable" )+  , ( NormalTok , "(" )+  , ( FunctionTok , "words" )+  , ( NormalTok , "(" )+  , ( DecValTok , "2" )+  , ( NormalTok , "), blocks)) " )+  , ( CommentTok , "// BOOK not" )+  ]+, [ ( NormalTok , "  " )+  , ( FunctionTok , "assert" )+  , ( NormalTok , "(" )+  , ( FunctionTok , "isMakeable" )+  , ( NormalTok , "(" )+  , ( FunctionTok , "words" )+  , ( NormalTok , "(" )+  , ( DecValTok , "3" )+  , ( NormalTok , "), blocks))" )+  ]+, [ ( NormalTok , "  " )+  , ( FunctionTok , "assert" )+  , ( NormalTok , "(!" )+  , ( FunctionTok , "isMakeable" )+  , ( NormalTok , "(" )+  , ( FunctionTok , "words" )+  , ( NormalTok , "(" )+  , ( DecValTok , "4" )+  , ( NormalTok , "), blocks)) " )+  , ( CommentTok , "// COMMON not" )+  ]+, [ ( NormalTok , "  " )+  , ( FunctionTok , "assert" )+  , ( NormalTok , "(" )+  , ( FunctionTok , "isMakeable" )+  , ( NormalTok , "(" )+  , ( FunctionTok , "words" )+  , ( NormalTok , "(" )+  , ( DecValTok , "5" )+  , ( NormalTok , "), blocks))" )+  ]+, [ ( NormalTok , "  " )+  , ( FunctionTok , "assert" )+  , ( NormalTok , "(" )+  , ( FunctionTok , "isMakeable" )+  , ( NormalTok , "(" )+  , ( FunctionTok , "words" )+  , ( NormalTok , "(" )+  , ( DecValTok , "6" )+  , ( NormalTok , "), blocks))" )+  ]+, [ ( NormalTok , "  " )+  , ( FunctionTok , "assert" )+  , ( NormalTok , "(" )+  , ( FunctionTok , "isMakeable" )+  , ( NormalTok , "(" )+  , ( FunctionTok , "words" )+  , ( NormalTok , "(" )+  , ( DecValTok , "7" )+  , ( NormalTok , "), blocks))" )+  ]+, []+, [ ( NormalTok , "  " )+  , ( CommentTok+    , "//words(7).mkString.permutations.foreach(s => assert(isMakeable(s, blocks)))"+    )+  ]+, []+, [ ( NormalTok , "  words." )+  , ( FunctionTok , "foreach" )+  , ( NormalTok , "(w => " )+  , ( FunctionTok , "println" )+  , ( NormalTok , "(s" )+  , ( StringTok , "\"$w can${if (isMakeable(w, blocks)) \"" )+  , ( NormalTok , " " )+  , ( StringTok , "\" else \"" )+  , ( NormalTok , "not " )+  , ( StringTok , "\"}be made.\"" )+  , ( NormalTok , "))" )+  ]+, [ ( NormalTok , "}" ) ]+]
+ test/expected/abc.scheme.native view
@@ -0,0 +1,205 @@+[ [ ( NormalTok , "#lang racket" ) ]+, [ ( NormalTok , "(" )+  , ( KeywordTok , "define" )+  , ( FunctionTok , " block-strings" )+  ]+, [ ( NormalTok , "  (" )+  , ( KeywordTok , "list" )+  , ( NormalTok , " " )+  , ( StringTok , "\"BO\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"XK\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"DQ\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"CP\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"NA\"" )+  ]+, [ ( NormalTok , "        " )+  , ( StringTok , "\"GT\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"RE\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"TG\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"QD\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"FS\"" )+  ]+, [ ( NormalTok , "        " )+  , ( StringTok , "\"JW\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"HU\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"VI\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"AN\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"OB\"" )+  ]+, [ ( NormalTok , "        " )+  , ( StringTok , "\"ER\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"FS\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"LY\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"PC\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"ZM\"" )+  , ( NormalTok , "))" )+  ]+, [ ( NormalTok , "(" )+  , ( KeywordTok , "define" )+  , ( FunctionTok , " BLOCKS " )+  , ( NormalTok , "(map " )+  , ( KeywordTok , "string->list" )+  , ( NormalTok , " block-strings))" )+  ]+, []+, [ ( NormalTok , "(" )+  , ( KeywordTok , "define" )+  , ( FunctionTok , " " )+  , ( NormalTok , "(can-make-word? w)" )+  ]+, [ ( NormalTok , "  (" )+  , ( KeywordTok , "define" )+  , ( FunctionTok , " " )+  , ( NormalTok , "(usable-block blocks word-char)" )+  ]+, [ ( NormalTok+    , "    (for/first ((b (in-list blocks)) #:when (memf (curry "+    )+  , ( KeywordTok , "char-ci=?" )+  , ( NormalTok , " word-char) b)) b))" )+  ]+, [ ( NormalTok , "  " ) ]+, [ ( NormalTok , "  (" )+  , ( KeywordTok , "define" )+  , ( FunctionTok , " " )+  , ( NormalTok , "(inner word-chars blocks tried-blocks)" )+  ]+, [ ( NormalTok , "    (" ) , ( KeywordTok , "cond" ) ]+, [ ( NormalTok , "      [(" )+  , ( KeywordTok , "null?" )+  , ( NormalTok , " word-chars) " )+  , ( DecValTok , "#t" )+  , ( NormalTok , "]" )+  ]+, [ ( NormalTok , "      [(usable-block blocks (" )+  , ( KeywordTok , "car" )+  , ( NormalTok , " word-chars))" )+  ]+, [ ( NormalTok , "       " ) , ( KeywordTok , "=>" ) ]+, [ ( NormalTok , "       (" )+  , ( KeywordTok , "lambda" )+  , ( NormalTok , " (b)" )+  ]+, [ ( NormalTok , "         (" ) , ( KeywordTok , "or" ) ]+, [ ( NormalTok , "          (inner (" )+  , ( KeywordTok , "cdr" )+  , ( NormalTok , " word-chars) (" )+  , ( KeywordTok , "append" )+  , ( NormalTok , " tried-blocks (remove b blocks)) null)" )+  ]+, [ ( NormalTok+    , "          (inner word-chars (remove b blocks) ("+    )+  , ( KeywordTok , "cons" )+  , ( NormalTok , " b tried-blocks))))]" )+  ]+, [ ( NormalTok , "      [" )+  , ( KeywordTok , "else" )+  , ( NormalTok , " " )+  , ( DecValTok , "#f" )+  , ( NormalTok , "]))" )+  ]+, [ ( NormalTok , "  (inner (" )+  , ( KeywordTok , "string->list" )+  , ( NormalTok , " w) BLOCKS null))" )+  ]+, []+, [ ( NormalTok , "(" )+  , ( KeywordTok , "define" )+  , ( FunctionTok , " WORD-LIST " )+  , ( NormalTok , "'(" )+  , ( StringTok , "\"\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"A\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"BARK\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"BOOK\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"TREAT\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"COMMON\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"SQUAD\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"CONFUSE\"" )+  , ( NormalTok , "))" )+  ]+, [ ( NormalTok , "(" )+  , ( KeywordTok , "define" )+  , ( FunctionTok , " " )+  , ( NormalTok , "(report-word w)" )+  ]+, [ ( NormalTok , "  (printf " )+  , ( StringTok , "\"Can we make: ~a? ~a~%\"" )+  ]+, [ ( NormalTok , "          (~s w #:min-width " )+  , ( DecValTok , "9" )+  , ( NormalTok , ")" )+  ]+, [ ( NormalTok , "          (" )+  , ( KeywordTok , "if" )+  , ( NormalTok , " (can-make-word? w) " )+  , ( StringTok , "\"yes\"" )+  , ( NormalTok , " " )+  , ( StringTok , "\"no\"" )+  , ( NormalTok , ")))" )+  ]+, []+, [ ( NormalTok , "(module+ main" ) ]+, [ ( NormalTok , "  (" )+  , ( KeywordTok , "for-each" )+  , ( NormalTok , " report-word WORD-LIST))  " )+  ]+, []+, [ ( NormalTok , "(module+ test" ) ]+, [ ( NormalTok , "  (require rackunit)" ) ]+, [ ( NormalTok , "  (check-true  (can-make-word? " )+  , ( StringTok , "\"\"" )+  , ( NormalTok , "))" )+  ]+, [ ( NormalTok , "  (check-true  (can-make-word? " )+  , ( StringTok , "\"A\"" )+  , ( NormalTok , "))" )+  ]+, [ ( NormalTok , "  (check-true  (can-make-word? " )+  , ( StringTok , "\"BARK\"" )+  , ( NormalTok , "))" )+  ]+, [ ( NormalTok , "  (check-false (can-make-word? " )+  , ( StringTok , "\"BOOK\"" )+  , ( NormalTok , "))" )+  ]+, [ ( NormalTok , "  (check-true  (can-make-word? " )+  , ( StringTok , "\"TREAT\"" )+  , ( NormalTok , "))" )+  ]+, [ ( NormalTok , "  (check-false (can-make-word? " )+  , ( StringTok , "\"COMMON\"" )+  , ( NormalTok , "))" )+  ]+, [ ( NormalTok , "  (check-true  (can-make-word? " )+  , ( StringTok , "\"SQUAD\"" )+  , ( NormalTok , "))" )+  ]+, [ ( NormalTok , "  (check-true  (can-make-word? " )+  , ( StringTok , "\"CONFUSE\"" )+  , ( NormalTok , ")))" )+  ]+]
+ test/expected/abc.tcl.native view
@@ -0,0 +1,157 @@+[ [ ( KeywordTok , "package" )+  , ( NormalTok , " " )+  , ( OtherTok , "require" )+  , ( NormalTok , " Tcl " )+  , ( FloatTok , "8.6" )+  ]+, []+, [ ( KeywordTok , "proc" )+  , ( NormalTok , " abc " )+  , ( KeywordTok , "{" )+  , ( NormalTok , "word " )+  , ( KeywordTok , "{" )+  , ( NormalTok , "blocks " )+  , ( KeywordTok , "{" )+  , ( NormalTok+    , "BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM"+    )+  , ( KeywordTok , "}}}" )+  , ( NormalTok , " " )+  , ( KeywordTok , "{" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "set" )+  , ( NormalTok , " abc " )+  , ( KeywordTok , "{{" )+  , ( NormalTok , "letters blocks abc" )+  , ( KeywordTok , "}" )+  , ( NormalTok , " " )+  , ( KeywordTok , "{" )+  ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "set" )+  , ( NormalTok , " rest " )+  , ( KeywordTok , "[lassign" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "$letters" )+  , ( NormalTok , " ch" )+  , ( KeywordTok , "]" )+  ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "set" )+  , ( NormalTok , " i " )+  , ( DecValTok , "0" )+  ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "foreach" )+  , ( NormalTok , " blk " )+  , ( DataTypeTok , "$blocks" )+  , ( NormalTok , " " )+  , ( KeywordTok , "{" )+  ]+, [ ( NormalTok , "            " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " " )+  , ( KeywordTok , "{" )+  , ( DataTypeTok , "$ch" )+  , ( NormalTok , " in " )+  , ( DataTypeTok , "$blk" )+  , ( NormalTok , " && (!" )+  , ( KeywordTok , "[llength" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "$rest" )+  , ( KeywordTok , "]" )+  ]+, [ ( NormalTok , "                    || " )+  , ( KeywordTok , "[" )+  , ( NormalTok , "apply " )+  , ( DataTypeTok , "$abc" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "$rest" )+  , ( NormalTok , " " )+  , ( KeywordTok , "[lreplace" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "$blocks" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "$i" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "$i" )+  , ( KeywordTok , "]" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "$abc" )+  , ( KeywordTok , "]" )+  , ( NormalTok , ")" )+  , ( KeywordTok , "}" )+  , ( NormalTok , " " )+  , ( KeywordTok , "{" )+  ]+, [ ( NormalTok , "                " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " true" )+  ]+, [ ( NormalTok , "            " ) , ( KeywordTok , "}" ) ]+, [ ( NormalTok , "            " )+  , ( KeywordTok , "incr" )+  , ( NormalTok , " i" )+  ]+, [ ( NormalTok , "        " ) , ( KeywordTok , "}" ) ]+, [ ( NormalTok , "        " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " false" )+  ]+, [ ( NormalTok , "    " ) , ( KeywordTok , "}}" ) ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " " )+  , ( KeywordTok , "[" )+  , ( NormalTok , "apply " )+  , ( DataTypeTok , "$abc" )+  , ( NormalTok , " " )+  , ( KeywordTok , "[split" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "$word" )+  , ( NormalTok , " " )+  , ( StringTok , "\"\"" )+  , ( KeywordTok , "]" )+  , ( NormalTok , " " )+  , ( KeywordTok , "[" )+  , ( NormalTok , "lmap b " )+  , ( DataTypeTok , "$blocks" )+  , ( NormalTok , " " )+  , ( KeywordTok , "{split" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "$b" )+  , ( NormalTok , " " )+  , ( StringTok , "\"\"" )+  , ( KeywordTok , "}]" )+  , ( NormalTok , " " )+  , ( DataTypeTok , "$abc" )+  , ( KeywordTok , "]" )+  ]+, [ ( KeywordTok , "}" ) ]+, []+, [ ( KeywordTok , "foreach" )+  , ( NormalTok , " word " )+  , ( KeywordTok , "{" )+  , ( StringTok , "\"\"" )+  , ( NormalTok , " A BARK BOOK TREAT COMMON SQUAD CONFUSE" )+  , ( KeywordTok , "}" )+  , ( NormalTok , " " )+  , ( KeywordTok , "{" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "puts" )+  , ( NormalTok , " " )+  , ( KeywordTok , "[format" )+  , ( NormalTok , " " )+  , ( StringTok , "\"Can we spell %9s? %s\"" )+  , ( NormalTok , " '" )+  , ( DataTypeTok , "$word" )+  , ( NormalTok , "' " )+  , ( KeywordTok , "[" )+  , ( NormalTok , "abc " )+  , ( DataTypeTok , "$word" )+  , ( KeywordTok , "]]" )+  ]+, [ ( KeywordTok , "}" ) ]+]
+ test/expected/archive.rhtml.native view
@@ -0,0 +1,137 @@+[ [ ( KeywordTok , "<h1>" )+  , ( NormalTok , "Event Archive" )+  , ( KeywordTok , "</h1>" )+  ]+, []+, []+, [ ( KeywordTok , "<%" )+  , ( NormalTok , " form_for " )+  , ( StringTok , ":to_date" )+  , ( NormalTok , ", " )+  , ( OtherTok , "@to_date" )+  , ( NormalTok , ", " )+  , ( StringTok , ":url" )+  , ( NormalTok , " " )+  , ( CharTok , "=>" )+  , ( NormalTok , " " )+  , ( CharTok , "{" )+  , ( StringTok , ":action" )+  , ( NormalTok , " " )+  , ( CharTok , "=>" )+  , ( NormalTok , " " )+  , ( StringTok , "'archive'" )+  , ( CharTok , "}" )+  , ( NormalTok , " " )+  , ( KeywordTok , "do" )+  , ( NormalTok , " " )+  , ( CharTok , "|" )+  , ( NormalTok , "f" )+  , ( CharTok , "|" )+  , ( NormalTok , " " )+  , ( KeywordTok , "%>" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "<p><label" )+  , ( OtherTok , " for=" )+  , ( StringTok , "\"start_date\"" )+  , ( KeywordTok , ">" )+  , ( NormalTok , "From" )+  , ( KeywordTok , "</label>" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "<%=" )+  , ( NormalTok , " select_date " )+  , ( OtherTok , "@from_date" )+  , ( NormalTok , ", " )+  , ( StringTok , ":prefix" )+  , ( NormalTok , " " )+  , ( CharTok , "=>" )+  , ( NormalTok , " " )+  , ( StringTok , "'from'" )+  , ( NormalTok , " " )+  , ( KeywordTok , "%>" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "<label" )+  , ( OtherTok , " for=" )+  , ( StringTok , "\"end_date\"" )+  , ( KeywordTok , ">" )+  , ( NormalTok , "To" )+  , ( KeywordTok , "</label>" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "<%=" )+  , ( NormalTok , " select_date " )+  , ( OtherTok , "@to_date" )+  , ( NormalTok , ", " )+  , ( StringTok , ":prefix" )+  , ( NormalTok , " " )+  , ( CharTok , "=>" )+  , ( NormalTok , " " )+  , ( StringTok , "'to'" )+  , ( NormalTok , ", " )+  , ( StringTok , ":start_year" )+  , ( NormalTok , " " )+  , ( CharTok , "=>" )+  , ( NormalTok , " " )+  , ( DecValTok , "2000" )+  , ( NormalTok , " " )+  , ( KeywordTok , "%></p>" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "<p><label" )+  , ( OtherTok , " for=" )+  , ( StringTok , "\"event_series\"" )+  , ( KeywordTok , ">" )+  , ( NormalTok , "Series" )+  , ( KeywordTok , "</label>" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "<%=" )+  , ( NormalTok , " select_tag " )+  , ( StringTok , "\"series\"" )+  , ( NormalTok , ", options_for_select(series_list(" )+  , ( StringTok , "'All'" )+  , ( NormalTok , "), " )+  , ( OtherTok , "@series" )+  , ( NormalTok , ") " )+  , ( KeywordTok , "%>" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "<%=" )+  , ( NormalTok , " f.submit " )+  , ( StringTok , "'Show events'" )+  , ( NormalTok , " " )+  , ( KeywordTok , "%>" )+  ]+, [ ( NormalTok , "  " ) , ( KeywordTok , "</p>" ) ]+, [ ( KeywordTok , "<%" )+  , ( NormalTok , " " )+  , ( KeywordTok , "end" )+  , ( NormalTok , " " )+  , ( KeywordTok , "%>" )+  ]+, []+, [ ( KeywordTok , "<ul>" ) ]+, [ ( KeywordTok , "<%" ) ]+, [ ( KeywordTok , "if" )+  , ( NormalTok , " " )+  , ( OtherTok , "@events" )+  ]+, [ ( KeywordTok , "%>" ) ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "<%=" )+  , ( NormalTok , " render " )+  , ( StringTok , ":partial" )+  , ( NormalTok , " " )+  , ( CharTok , "=>" )+  , ( NormalTok , " " )+  , ( StringTok , "'events'" )+  , ( NormalTok , " " )+  , ( KeywordTok , "%>" )+  ]+, [ ( KeywordTok , "<%" ) ]+, [ ( KeywordTok , "end" ) ]+, [ ( KeywordTok , "%>" ) ]+, [ ( KeywordTok , "</ul>" ) ]+]
+ test/expected/hk91.html.native view
@@ -0,0 +1,100 @@+[ [ ( DataTypeTok , "<!DOCTYPE " )+  , ( NormalTok , "HTML" )+  , ( DataTypeTok , ">" )+  ]+, [ ( KeywordTok , "<html>" ) ]+, [ ( KeywordTok , "<head>" ) ]+, []+, [ ( NormalTok , "  " )+  , ( KeywordTok , "<script" )+  , ( OtherTok , " type=" )+  , ( StringTok , "\"text/javascript\"" )+  , ( KeywordTok , ">" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "function" )+  , ( NormalTok , " " )+  , ( AttributeTok , "makeHeaders" )+  , ( NormalTok , "(colnames) " )+  , ( OperatorTok , "{" )+  ]+, [ ( NormalTok , "      " )+  , ( KeywordTok , "var" )+  , ( NormalTok , " str " )+  , ( OperatorTok , "=" )+  , ( NormalTok , " " )+  , ( StringTok , "\"\"" )+  , ( OperatorTok , ";" )+  ]+, [ ( NormalTok , "      " )+  , ( ControlFlowTok , "for" )+  , ( NormalTok , " (" )+  , ( KeywordTok , "var" )+  , ( NormalTok , " i " )+  , ( OperatorTok , "=" )+  , ( NormalTok , " " )+  , ( DecValTok , "0" )+  , ( OperatorTok , ";" )+  , ( NormalTok , " i " )+  , ( OperatorTok , "<" )+  , ( NormalTok , " " )+  , ( VariableTok , "colnames" )+  , ( NormalTok , "." )+  , ( AttributeTok , "length" )+  , ( OperatorTok , ";" )+  , ( NormalTok , " i" )+  , ( OperatorTok , "++" )+  , ( NormalTok , ") " )+  , ( OperatorTok , "{" )+  ]+, [ ( NormalTok , "        str " )+  , ( OperatorTok , "+=" )+  , ( NormalTok , " " )+  , ( StringTok , "\"<th>\"" )+  , ( NormalTok , " " )+  , ( OperatorTok , "+" )+  , ( NormalTok , " colnames[i] " )+  , ( OperatorTok , "+" )+  , ( NormalTok , " " )+  , ( StringTok , "\"</th>\"" )+  , ( OperatorTok , ";" )+  ]+, [ ( NormalTok , "      " ) , ( OperatorTok , "}" ) ]+, [ ( NormalTok , "      " )+  , ( ControlFlowTok , "return" )+  , ( NormalTok , " (str)" )+  , ( OperatorTok , ";" )+  ]+, [ ( NormalTok , "    " ) , ( OperatorTok , "}" ) ]+, [ ( NormalTok , "  " ) , ( KeywordTok , "</script>" ) ]+, []+, [ ( NormalTok , "  " ) , ( KeywordTok , "<script>" ) ]+, [ ( NormalTok , "    " )+  , ( AttributeTok , "$" )+  , ( NormalTok , "(document)." )+  , ( AttributeTok , "ready" )+  , ( NormalTok , "(" )+  , ( KeywordTok , "function" )+  , ( NormalTok , "() " )+  , ( OperatorTok , "{" )+  ]+, [ ( NormalTok , "      alert" )+  , ( StringTok , "\"hello\"" )+  , ( NormalTok , ")" )+  , ( OperatorTok , ";" )+  ]+, [ ( NormalTok , "    " )+  , ( OperatorTok , "}" )+  , ( NormalTok , ")" )+  , ( OperatorTok , ";" )+  ]+, [ ( NormalTok , "  " ) , ( KeywordTok , "</script>" ) ]+, []+, [ ( KeywordTok , "</head>" ) ]+, []+, [ ( KeywordTok , "<body>" ) ]+, []+, [ ( KeywordTok , "</body>" ) ]+, []+, [ ( KeywordTok , "</html>" ) ]+]
+ test/expected/life.lua.native view
@@ -0,0 +1,959 @@+[ [ ( DocumentationTok , "-- life.lua" ) ]+, [ ( DocumentationTok , "-- original by Dave Bollinger " )+  , ( KeywordTok , "<DBollinger" )+  , ( OtherTok , "@compuserve.com" )+  , ( KeywordTok , ">" )+  , ( DocumentationTok , " posted to lua-l" )+  ]+, [ ( DocumentationTok+    , "-- modified to use ANSI terminal escape sequences"+    )+  ]+, [ ( DocumentationTok+    , "-- modified to use for instead of while"+    )+  ]+, []+, [ ( KeywordTok , "local" )+  , ( NormalTok , " " )+  , ( FunctionTok , "write" )+  , ( OtherTok , "=" )+  , ( FunctionTok , "io.write" )+  ]+, []+, [ ( NormalTok , "ALIVE" )+  , ( OtherTok , "=" )+  , ( StringTok , "\"\165\"" )+  , ( NormalTok , "\tDEAD" )+  , ( OtherTok , "=" )+  , ( StringTok , "\"\254\"" )+  ]+, [ ( NormalTok , "ALIVE" )+  , ( OtherTok , "=" )+  , ( StringTok , "\"O\"" )+  , ( NormalTok , "\tDEAD" )+  , ( OtherTok , "=" )+  , ( StringTok , "\"-\"" )+  ]+, []+, [ ( KeywordTok , "function" )+  , ( NormalTok , " delay" )+  , ( OtherTok , "()" )+  , ( NormalTok , " " )+  , ( DocumentationTok , "-- " )+  , ( AlertTok , "NOTE" )+  , ( DocumentationTok , ": SYSTEM-DEPENDENT, adjust as necessary" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "for" )+  , ( NormalTok , " i" )+  , ( OtherTok , "=" )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "10000" )+  , ( NormalTok , " " )+  , ( KeywordTok , "do" )+  , ( NormalTok , " " )+  , ( KeywordTok , "end" )+  ]+, [ ( NormalTok , "  " )+  , ( DocumentationTok , "-- local i=os.clock()+1 while(os.clock()" )+  , ( KeywordTok , "<i" )+  , ( OtherTok , ") do end" )+  ]+, [ ( KeywordTok , "end" ) ]+, []+, [ ( KeywordTok , "function" )+  , ( NormalTok , " ARRAY2D" )+  , ( OtherTok , "(" )+  , ( NormalTok , "w" )+  , ( OtherTok , "," )+  , ( NormalTok , "h" )+  , ( OtherTok , ")" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "local" )+  , ( NormalTok , " t " )+  , ( OtherTok , "=" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , "w" )+  , ( OtherTok , "=" )+  , ( NormalTok , "w" )+  , ( OtherTok , "," )+  , ( NormalTok , "h" )+  , ( OtherTok , "=" )+  , ( NormalTok , "h" )+  , ( OtherTok , "}" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "for" )+  , ( NormalTok , " y" )+  , ( OtherTok , "=" )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( NormalTok , "h " )+  , ( KeywordTok , "do" )+  ]+, [ ( NormalTok , "    t" )+  , ( OtherTok , "[" )+  , ( NormalTok , "y" )+  , ( OtherTok , "]" )+  , ( NormalTok , " " )+  , ( OtherTok , "=" )+  , ( NormalTok , " " )+  , ( OtherTok , "{}" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "for" )+  , ( NormalTok , " x" )+  , ( OtherTok , "=" )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( NormalTok , "w " )+  , ( KeywordTok , "do" )+  ]+, [ ( NormalTok , "      t" )+  , ( OtherTok , "[" )+  , ( NormalTok , "y" )+  , ( OtherTok , "][" )+  , ( NormalTok , "x" )+  , ( OtherTok , "]=" )+  , ( DecValTok , "0" )+  ]+, [ ( NormalTok , "    " ) , ( KeywordTok , "end" ) ]+, [ ( NormalTok , "  " ) , ( KeywordTok , "end" ) ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " t" )+  ]+, [ ( KeywordTok , "end" ) ]+, []+, [ ( NormalTok , "_CELLS " )+  , ( OtherTok , "=" )+  , ( NormalTok , " " )+  , ( OtherTok , "{}" )+  ]+, []+, [ ( DocumentationTok+    , "-- give birth to a \"shape\" within the cell array"+    )+  ]+, [ ( KeywordTok , "function" )+  , ( NormalTok , " _CELLS:spawn" )+  , ( OtherTok , "(" )+  , ( NormalTok , "shape" )+  , ( OtherTok , "," )+  , ( NormalTok , "left" )+  , ( OtherTok , "," )+  , ( NormalTok , "top" )+  , ( OtherTok , ")" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "for" )+  , ( NormalTok , " y" )+  , ( OtherTok , "=" )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( NormalTok , "shape" )+  , ( OtherTok , "." )+  , ( NormalTok , "h" )+  , ( OtherTok , "-" )+  , ( DecValTok , "1" )+  , ( NormalTok , " " )+  , ( KeywordTok , "do" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "for" )+  , ( NormalTok , " x" )+  , ( OtherTok , "=" )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( NormalTok , "shape" )+  , ( OtherTok , "." )+  , ( NormalTok , "w" )+  , ( OtherTok , "-" )+  , ( DecValTok , "1" )+  , ( NormalTok , " " )+  , ( KeywordTok , "do" )+  ]+, [ ( NormalTok , "      self" )+  , ( OtherTok , "[" )+  , ( NormalTok , "top" )+  , ( OtherTok , "+" )+  , ( NormalTok , "y" )+  , ( OtherTok , "][" )+  , ( NormalTok , "left" )+  , ( OtherTok , "+" )+  , ( NormalTok , "x" )+  , ( OtherTok , "]" )+  , ( NormalTok , " " )+  , ( OtherTok , "=" )+  , ( NormalTok , " shape" )+  , ( OtherTok , "[" )+  , ( NormalTok , "y" )+  , ( OtherTok , "*" )+  , ( NormalTok , "shape" )+  , ( OtherTok , "." )+  , ( NormalTok , "w" )+  , ( OtherTok , "+" )+  , ( NormalTok , "x" )+  , ( OtherTok , "+" )+  , ( DecValTok , "1" )+  , ( OtherTok , "]" )+  ]+, [ ( NormalTok , "    " ) , ( KeywordTok , "end" ) ]+, [ ( NormalTok , "  " ) , ( KeywordTok , "end" ) ]+, [ ( KeywordTok , "end" ) ]+, []+, [ ( DocumentationTok+    , "-- run the CA and produce the next generation"+    )+  ]+, [ ( KeywordTok , "function" )+  , ( NormalTok , " _CELLS:evolve" )+  , ( OtherTok , "(" )+  , ( FunctionTok , "next" )+  , ( OtherTok , ")" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "local" )+  , ( NormalTok , " ym1" )+  , ( OtherTok , "," )+  , ( NormalTok , "y" )+  , ( OtherTok , "," )+  , ( NormalTok , "yp1" )+  , ( OtherTok , "," )+  , ( NormalTok , "yi" )+  , ( OtherTok , "=" )+  , ( NormalTok , "self" )+  , ( OtherTok , "." )+  , ( NormalTok , "h" )+  , ( OtherTok , "-" )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( NormalTok , "self" )+  , ( OtherTok , "." )+  , ( NormalTok , "h" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( NormalTok , "self" )+  , ( OtherTok , "." )+  , ( NormalTok , "h" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "while" )+  , ( NormalTok , " yi " )+  , ( OtherTok , ">" )+  , ( NormalTok , " " )+  , ( DecValTok , "0" )+  , ( NormalTok , " " )+  , ( KeywordTok , "do" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "local" )+  , ( NormalTok , " xm1" )+  , ( OtherTok , "," )+  , ( NormalTok , "x" )+  , ( OtherTok , "," )+  , ( NormalTok , "xp1" )+  , ( OtherTok , "," )+  , ( NormalTok , "xi" )+  , ( OtherTok , "=" )+  , ( NormalTok , "self" )+  , ( OtherTok , "." )+  , ( NormalTok , "w" )+  , ( OtherTok , "-" )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( NormalTok , "self" )+  , ( OtherTok , "." )+  , ( NormalTok , "w" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( NormalTok , "self" )+  , ( OtherTok , "." )+  , ( NormalTok , "w" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "while" )+  , ( NormalTok , " xi " )+  , ( OtherTok , ">" )+  , ( NormalTok , " " )+  , ( DecValTok , "0" )+  , ( NormalTok , " " )+  , ( KeywordTok , "do" )+  ]+, [ ( NormalTok , "      " )+  , ( KeywordTok , "local" )+  , ( NormalTok , " sum " )+  , ( OtherTok , "=" )+  , ( NormalTok , " self" )+  , ( OtherTok , "[" )+  , ( NormalTok , "ym1" )+  , ( OtherTok , "][" )+  , ( NormalTok , "xm1" )+  , ( OtherTok , "]" )+  , ( NormalTok , " " )+  , ( OtherTok , "+" )+  , ( NormalTok , " self" )+  , ( OtherTok , "[" )+  , ( NormalTok , "ym1" )+  , ( OtherTok , "][" )+  , ( NormalTok , "x" )+  , ( OtherTok , "]" )+  , ( NormalTok , " " )+  , ( OtherTok , "+" )+  , ( NormalTok , " self" )+  , ( OtherTok , "[" )+  , ( NormalTok , "ym1" )+  , ( OtherTok , "][" )+  , ( NormalTok , "xp1" )+  , ( OtherTok , "]" )+  , ( NormalTok , " " )+  , ( OtherTok , "+" )+  ]+, [ ( NormalTok , "                  self" )+  , ( OtherTok , "[" )+  , ( NormalTok , "y" )+  , ( OtherTok , "][" )+  , ( NormalTok , "xm1" )+  , ( OtherTok , "]" )+  , ( NormalTok , " " )+  , ( OtherTok , "+" )+  , ( NormalTok , " self" )+  , ( OtherTok , "[" )+  , ( NormalTok , "y" )+  , ( OtherTok , "][" )+  , ( NormalTok , "xp1" )+  , ( OtherTok , "]" )+  , ( NormalTok , " " )+  , ( OtherTok , "+" )+  ]+, [ ( NormalTok , "                  self" )+  , ( OtherTok , "[" )+  , ( NormalTok , "yp1" )+  , ( OtherTok , "][" )+  , ( NormalTok , "xm1" )+  , ( OtherTok , "]" )+  , ( NormalTok , " " )+  , ( OtherTok , "+" )+  , ( NormalTok , " self" )+  , ( OtherTok , "[" )+  , ( NormalTok , "yp1" )+  , ( OtherTok , "][" )+  , ( NormalTok , "x" )+  , ( OtherTok , "]" )+  , ( NormalTok , " " )+  , ( OtherTok , "+" )+  , ( NormalTok , " self" )+  , ( OtherTok , "[" )+  , ( NormalTok , "yp1" )+  , ( OtherTok , "][" )+  , ( NormalTok , "xp1" )+  , ( OtherTok , "]" )+  ]+, [ ( NormalTok , "      " )+  , ( FunctionTok , "next" )+  , ( OtherTok , "[" )+  , ( NormalTok , "y" )+  , ( OtherTok , "][" )+  , ( NormalTok , "x" )+  , ( OtherTok , "]" )+  , ( NormalTok , " " )+  , ( OtherTok , "=" )+  , ( NormalTok , " " )+  , ( OtherTok , "((" )+  , ( NormalTok , "sum" )+  , ( OtherTok , "==" )+  , ( DecValTok , "2" )+  , ( OtherTok , ")" )+  , ( NormalTok , " " )+  , ( KeywordTok , "and" )+  , ( NormalTok , " self" )+  , ( OtherTok , "[" )+  , ( NormalTok , "y" )+  , ( OtherTok , "][" )+  , ( NormalTok , "x" )+  , ( OtherTok , "])" )+  , ( NormalTok , " " )+  , ( KeywordTok , "or" )+  , ( NormalTok , " " )+  , ( OtherTok , "((" )+  , ( NormalTok , "sum" )+  , ( OtherTok , "==" )+  , ( DecValTok , "3" )+  , ( OtherTok , ")" )+  , ( NormalTok , " " )+  , ( KeywordTok , "and" )+  , ( NormalTok , " " )+  , ( DecValTok , "1" )+  , ( OtherTok , ")" )+  , ( NormalTok , " " )+  , ( KeywordTok , "or" )+  , ( NormalTok , " " )+  , ( DecValTok , "0" )+  ]+, [ ( NormalTok , "      xm1" )+  , ( OtherTok , "," )+  , ( NormalTok , "x" )+  , ( OtherTok , "," )+  , ( NormalTok , "xp1" )+  , ( OtherTok , "," )+  , ( NormalTok , "xi " )+  , ( OtherTok , "=" )+  , ( NormalTok , " x" )+  , ( OtherTok , "," )+  , ( NormalTok , "xp1" )+  , ( OtherTok , "," )+  , ( NormalTok , "xp1" )+  , ( OtherTok , "+" )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( NormalTok , "xi" )+  , ( OtherTok , "-" )+  , ( DecValTok , "1" )+  ]+, [ ( NormalTok , "    " ) , ( KeywordTok , "end" ) ]+, [ ( NormalTok , "    ym1" )+  , ( OtherTok , "," )+  , ( NormalTok , "y" )+  , ( OtherTok , "," )+  , ( NormalTok , "yp1" )+  , ( OtherTok , "," )+  , ( NormalTok , "yi " )+  , ( OtherTok , "=" )+  , ( NormalTok , " y" )+  , ( OtherTok , "," )+  , ( NormalTok , "yp1" )+  , ( OtherTok , "," )+  , ( NormalTok , "yp1" )+  , ( OtherTok , "+" )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( NormalTok , "yi" )+  , ( OtherTok , "-" )+  , ( DecValTok , "1" )+  ]+, [ ( NormalTok , "  " ) , ( KeywordTok , "end" ) ]+, [ ( KeywordTok , "end" ) ]+, []+, [ ( DocumentationTok , "-- output the array to screen" ) ]+, [ ( KeywordTok , "function" )+  , ( NormalTok , " _CELLS:draw" )+  , ( OtherTok , "()" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "local" )+  , ( NormalTok , " out" )+  , ( OtherTok , "=" )+  , ( StringTok , "\"\"" )+  , ( NormalTok , " " )+  , ( DocumentationTok , "-- accumulate to reduce flicker" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "for" )+  , ( NormalTok , " y" )+  , ( OtherTok , "=" )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( NormalTok , "self" )+  , ( OtherTok , "." )+  , ( NormalTok , "h " )+  , ( KeywordTok , "do" )+  ]+, [ ( NormalTok , "   " )+  , ( KeywordTok , "for" )+  , ( NormalTok , " x" )+  , ( OtherTok , "=" )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( NormalTok , "self" )+  , ( OtherTok , "." )+  , ( NormalTok , "w " )+  , ( KeywordTok , "do" )+  ]+, [ ( NormalTok , "      out" )+  , ( OtherTok , "=" )+  , ( NormalTok , "out" )+  , ( OtherTok , "..(((" )+  , ( NormalTok , "self" )+  , ( OtherTok , "[" )+  , ( NormalTok , "y" )+  , ( OtherTok , "][" )+  , ( NormalTok , "x" )+  , ( OtherTok , "]>" )+  , ( DecValTok , "0" )+  , ( OtherTok , ")" )+  , ( NormalTok , " " )+  , ( KeywordTok , "and" )+  , ( NormalTok , " ALIVE" )+  , ( OtherTok , ")" )+  , ( NormalTok , " " )+  , ( KeywordTok , "or" )+  , ( NormalTok , " DEAD" )+  , ( OtherTok , ")" )+  ]+, [ ( NormalTok , "    " ) , ( KeywordTok , "end" ) ]+, [ ( NormalTok , "    out" )+  , ( OtherTok , "=" )+  , ( NormalTok , "out" )+  , ( OtherTok , ".." )+  , ( StringTok , "\"" )+  , ( OtherTok , "\\n" )+  , ( StringTok , "\"" )+  ]+, [ ( NormalTok , "  " ) , ( KeywordTok , "end" ) ]+, [ ( NormalTok , "  " )+  , ( FunctionTok , "write" )+  , ( OtherTok , "(" )+  , ( NormalTok , "out" )+  , ( OtherTok , ")" )+  ]+, [ ( KeywordTok , "end" ) ]+, []+, [ ( DocumentationTok , "-- constructor" ) ]+, [ ( KeywordTok , "function" )+  , ( NormalTok , " CELLS" )+  , ( OtherTok , "(" )+  , ( NormalTok , "w" )+  , ( OtherTok , "," )+  , ( NormalTok , "h" )+  , ( OtherTok , ")" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "local" )+  , ( NormalTok , " c " )+  , ( OtherTok , "=" )+  , ( NormalTok , " ARRAY2D" )+  , ( OtherTok , "(" )+  , ( NormalTok , "w" )+  , ( OtherTok , "," )+  , ( NormalTok , "h" )+  , ( OtherTok , ")" )+  ]+, [ ( NormalTok , "  c" )+  , ( OtherTok , "." )+  , ( NormalTok , "spawn " )+  , ( OtherTok , "=" )+  , ( NormalTok , " _CELLS" )+  , ( OtherTok , "." )+  , ( NormalTok , "spawn" )+  ]+, [ ( NormalTok , "  c" )+  , ( OtherTok , "." )+  , ( NormalTok , "evolve " )+  , ( OtherTok , "=" )+  , ( NormalTok , " _CELLS" )+  , ( OtherTok , "." )+  , ( NormalTok , "evolve" )+  ]+, [ ( NormalTok , "  c" )+  , ( OtherTok , "." )+  , ( NormalTok , "draw " )+  , ( OtherTok , "=" )+  , ( NormalTok , " _CELLS" )+  , ( OtherTok , "." )+  , ( NormalTok , "draw" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "return" )+  , ( NormalTok , " c" )+  ]+, [ ( KeywordTok , "end" ) ]+, []+, [ ( DocumentationTok , "--" ) ]+, [ ( DocumentationTok+    , "-- shapes suitable for use with spawn() above"+    )+  ]+, [ ( DocumentationTok , "--" ) ]+, [ ( NormalTok , "HEART " )+  , ( OtherTok , "=" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , " " )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , ";" )+  , ( NormalTok , " w" )+  , ( OtherTok , "=" )+  , ( DecValTok , "3" )+  , ( OtherTok , "," )+  , ( NormalTok , "h" )+  , ( OtherTok , "=" )+  , ( DecValTok , "3" )+  , ( NormalTok , " " )+  , ( OtherTok , "}" )+  ]+, [ ( NormalTok , "GLIDER " )+  , ( OtherTok , "=" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , " " )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , ";" )+  , ( NormalTok , " w" )+  , ( OtherTok , "=" )+  , ( DecValTok , "3" )+  , ( OtherTok , "," )+  , ( NormalTok , "h" )+  , ( OtherTok , "=" )+  , ( DecValTok , "3" )+  , ( NormalTok , " " )+  , ( OtherTok , "}" )+  ]+, [ ( NormalTok , "EXPLODE " )+  , ( OtherTok , "=" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , " " )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , ";" )+  , ( NormalTok , " w" )+  , ( OtherTok , "=" )+  , ( DecValTok , "3" )+  , ( OtherTok , "," )+  , ( NormalTok , "h" )+  , ( OtherTok , "=" )+  , ( DecValTok , "4" )+  , ( NormalTok , " " )+  , ( OtherTok , "}" )+  ]+, [ ( NormalTok , "FISH " )+  , ( OtherTok , "=" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , " " )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , ";" )+  , ( NormalTok , " w" )+  , ( OtherTok , "=" )+  , ( DecValTok , "5" )+  , ( OtherTok , "," )+  , ( NormalTok , "h" )+  , ( OtherTok , "=" )+  , ( DecValTok , "4" )+  , ( NormalTok , " " )+  , ( OtherTok , "}" )+  ]+, [ ( NormalTok , "BUTTERFLY " )+  , ( OtherTok , "=" )+  , ( NormalTok , " " )+  , ( OtherTok , "{" )+  , ( NormalTok , " " )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "0" )+  , ( OtherTok , "," )+  , ( DecValTok , "1" )+  , ( OtherTok , ";" )+  , ( NormalTok , " w" )+  , ( OtherTok , "=" )+  , ( DecValTok , "5" )+  , ( OtherTok , "," )+  , ( NormalTok , "h" )+  , ( OtherTok , "=" )+  , ( DecValTok , "5" )+  , ( NormalTok , " " )+  , ( OtherTok , "}" )+  ]+, []+, [ ( DocumentationTok , "-- the main routine" ) ]+, [ ( KeywordTok , "function" )+  , ( NormalTok , " LIFE" )+  , ( OtherTok , "(" )+  , ( NormalTok , "w" )+  , ( OtherTok , "," )+  , ( NormalTok , "h" )+  , ( OtherTok , ")" )+  ]+, [ ( NormalTok , "  " )+  , ( DocumentationTok , "-- create two arrays" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "local" )+  , ( NormalTok , " thisgen " )+  , ( OtherTok , "=" )+  , ( NormalTok , " CELLS" )+  , ( OtherTok , "(" )+  , ( NormalTok , "w" )+  , ( OtherTok , "," )+  , ( NormalTok , "h" )+  , ( OtherTok , ")" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "local" )+  , ( NormalTok , " nextgen " )+  , ( OtherTok , "=" )+  , ( NormalTok , " CELLS" )+  , ( OtherTok , "(" )+  , ( NormalTok , "w" )+  , ( OtherTok , "," )+  , ( NormalTok , "h" )+  , ( OtherTok , ")" )+  ]+, []+, [ ( NormalTok , "  " )+  , ( DocumentationTok , "-- create some life" )+  ]+, [ ( NormalTok , "  " )+  , ( DocumentationTok+    , "-- about 1000 generations of fun, then a glider steady-state"+    )+  ]+, [ ( NormalTok , "  thisgen:spawn" )+  , ( OtherTok , "(" )+  , ( NormalTok , "GLIDER" )+  , ( OtherTok , "," )+  , ( DecValTok , "5" )+  , ( OtherTok , "," )+  , ( DecValTok , "4" )+  , ( OtherTok , ")" )+  ]+, [ ( NormalTok , "  thisgen:spawn" )+  , ( OtherTok , "(" )+  , ( NormalTok , "EXPLODE" )+  , ( OtherTok , "," )+  , ( DecValTok , "25" )+  , ( OtherTok , "," )+  , ( DecValTok , "10" )+  , ( OtherTok , ")" )+  ]+, [ ( NormalTok , "  thisgen:spawn" )+  , ( OtherTok , "(" )+  , ( NormalTok , "FISH" )+  , ( OtherTok , "," )+  , ( DecValTok , "4" )+  , ( OtherTok , "," )+  , ( DecValTok , "12" )+  , ( OtherTok , ")" )+  ]+, []+, [ ( NormalTok , "  " )+  , ( DocumentationTok , "-- run until break" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "local" )+  , ( NormalTok , " gen" )+  , ( OtherTok , "=" )+  , ( DecValTok , "1" )+  ]+, [ ( NormalTok , "  " )+  , ( FunctionTok , "write" )+  , ( OtherTok , "(" )+  , ( StringTok , "\"\\027[2J\"" )+  , ( OtherTok , ")" )+  , ( NormalTok , "\t" )+  , ( DocumentationTok , "-- ANSI clear screen" )+  ]+, [ ( NormalTok , "  " )+  , ( KeywordTok , "while" )+  , ( NormalTok , " " )+  , ( DecValTok , "1" )+  , ( NormalTok , " " )+  , ( KeywordTok , "do" )+  ]+, [ ( NormalTok , "    thisgen:evolve" )+  , ( OtherTok , "(" )+  , ( NormalTok , "nextgen" )+  , ( OtherTok , ")" )+  ]+, [ ( NormalTok , "    thisgen" )+  , ( OtherTok , "," )+  , ( NormalTok , "nextgen " )+  , ( OtherTok , "=" )+  , ( NormalTok , " nextgen" )+  , ( OtherTok , "," )+  , ( NormalTok , "thisgen" )+  ]+, [ ( NormalTok , "    " )+  , ( FunctionTok , "write" )+  , ( OtherTok , "(" )+  , ( StringTok , "\"\\027[H\"" )+  , ( OtherTok , ")" )+  , ( NormalTok , "\t" )+  , ( DocumentationTok , "-- ANSI home cursor" )+  ]+, [ ( NormalTok , "    thisgen:draw" ) , ( OtherTok , "()" ) ]+, [ ( NormalTok , "    " )+  , ( FunctionTok , "write" )+  , ( OtherTok , "(" )+  , ( StringTok , "\"Life - generation \"" )+  , ( OtherTok , "," )+  , ( NormalTok , "gen" )+  , ( OtherTok , "," )+  , ( StringTok , "\"" )+  , ( OtherTok , "\\n" )+  , ( StringTok , "\"" )+  , ( OtherTok , ")" )+  ]+, [ ( NormalTok , "    gen" )+  , ( OtherTok , "=" )+  , ( NormalTok , "gen" )+  , ( OtherTok , "+" )+  , ( DecValTok , "1" )+  ]+, [ ( NormalTok , "    " )+  , ( KeywordTok , "if" )+  , ( NormalTok , " gen" )+  , ( OtherTok , ">" )+  , ( DecValTok , "2000" )+  , ( NormalTok , " " )+  , ( KeywordTok , "then" )+  , ( NormalTok , " " )+  , ( KeywordTok , "break" )+  , ( NormalTok , " " )+  , ( KeywordTok , "end" )+  ]+, [ ( NormalTok , "    " )+  , ( DocumentationTok , "--delay()\t\t-- no delay" )+  ]+, [ ( NormalTok , "  " ) , ( KeywordTok , "end" ) ]+, [ ( KeywordTok , "end" ) ]+, []+, [ ( NormalTok , "LIFE" )+  , ( OtherTok , "(" )+  , ( DecValTok , "40" )+  , ( OtherTok , "," )+  , ( DecValTok , "20" )+  , ( OtherTok , ")" )+  ]+]
+ test/test-skylighting.hs view
@@ -0,0 +1,120 @@+{-# LANGUAGE CPP                 #-}+{-# LANGUAGE OverloadedStrings   #-}+{-# LANGUAGE ScopedTypeVariables #-}+module Main where+import Data.Aeson (decode)+import Data.Monoid ((<>))+import Data.Algorithm.Diff+import qualified Data.ByteString.Lazy as BL+import Data.Text (Text)+import qualified Data.Text as Text+import qualified Data.Text.IO as Text+import Skylighting+import System.Directory+import System.Environment (getArgs)+import System.FilePath+import Test.Tasty+import Test.Tasty.Golden.Advanced (goldenTest)+import Test.Tasty.HUnit+import Text.Show.Pretty++main :: IO ()+main = do+  inputs <- filter (\fp -> take 1 fp /= ".")+         <$> getDirectoryContents ("test" </> "cases")+  args <- getArgs+  let regen = "--regenerate" `elem` args+  defaultTheme <- BL.readFile ("test" </> "default.theme")+  defaultMain $ testGroup "skylighting tests" $+    [ testGroup "tokenizer tests" $+        map (tokenizerTest regen) inputs+    , testGroup "FromJSON instance tests"+       [ testCase "decode simple color" $+            Just (RGB 0x15 0xff 0xa0) @=? decode "\"#15ffa0\""+       , testCase "decode TokenStyle" $+            Just (TokenStyle{tokenColor = Just (RGB 0x1f 0x1c 0x1b),+                             tokenBackground = Nothing,+                             tokenBold = True,+                             tokenItalic = False,+                             tokenUnderline = False }) @=?+            decode "{ \"text-color\": \"#1f1c1b\", \"bold\": true }"+       , testCase "decode KDE theme to Style" $+            Just kate @=? decode defaultTheme+       ]+    , testGroup "Skylighting.Regex" $+      [ testCase "convertOctalEscapes" $+            "a\\700b\\700c\\x{800}" @=?+              convertOctalEscapes "a\\700b\\0700c\\o{4000}"+      ]+    , testGroup "Skylighting" $+      [ testCase "syntaxesByFilename" $+            ["Perl"] @=?+              map sName (syntaxesByFilename defaultSyntaxMap "foo/bar.pl")+      ]+    , testGroup "Regression tests" $+      [ testCase "perl quoting case" $ Right+           [ [ ( KeywordTok , "my" )+              , ( NormalTok , " " )+              , ( DataTypeTok , "$foo" )+              , ( NormalTok , " = " )+              , ( KeywordTok , "q/" )+              , ( StringTok , "bar" )+              , ( KeywordTok , "/" )+              , ( NormalTok , ";" )+              ]+            , [ ( KeywordTok , "my" )+              , ( NormalTok , " " )+              , ( DataTypeTok , "$baz" )+              , ( NormalTok , " = " )+              , ( KeywordTok , "'" )+              , ( StringTok , "quux" )+              , ( KeywordTok , "'" )+              , ( NormalTok , ";" )+              ]+            ] @=? tokenize TokenizerConfig{ syntaxMap = defaultSyntaxMap+                                          , traceOutput = False }+                     (maybe (error "could not find Perl syntax") id+                       (lookupSyntax "Perl" defaultSyntaxMap))+                     "my $foo = q/bar/;\nmy $baz = 'quux';\n"+      ]+    ]++compareValues :: FilePath -> Text -> Text -> IO (Maybe String)+compareValues referenceFile expected actual =+   if expected == actual+      then return $ Nothing+      else return $ Just $ unlines $+           [ "--- " ++ referenceFile+           , "+++ actual" ] +++           map (Text.unpack . vividize)+             (getDiff (Text.lines expected) (Text.lines actual))++tokenizerTest :: Bool -> FilePath -> TestTree+tokenizerTest regen inpFile = localOption (mkTimeout 1000000) $+  goldenTest testname getExpected getActual+      (compareValues referenceFile) updateGolden+  where testname = lang ++ " tokenizing of " ++ inpFile+        getExpected = Text.readFile referenceFile+        getActual = do+          code <- Text.readFile (casesdir </> inpFile)+          syntax <- case lookupSyntax (Text.pack lang) defaultSyntaxMap of+                         Just s  -> return s+                         Nothing -> fail $+                            "Could not find syntax definition for " ++ lang+          case tokenize TokenizerConfig{+                             traceOutput = False+                           , syntaxMap = defaultSyntaxMap } syntax $! code of+                 Left e   -> fail e+                 Right ls -> return $ Text.pack $ ppShow ls ++ "\n"+        updateGolden = if regen+                          then Text.writeFile referenceFile+                          else \_ -> return ()+        expecteddir = "test" </> "expected"+        casesdir = "test" </> "cases"+        referenceFile = expecteddir </> inpFile <.> "native"+        lang = drop 1 $ takeExtension inpFile++vividize :: Diff Text -> Text+vividize (Both s _) = "  " <> s+vividize (First s)  = "- " <> s+vividize (Second s) = "+ " <> s